Problem Statement

You are programming a robot which lives on an infinite grid of empty cells. Each cell can be described by two integer coordinates (x, y). The robot always occupies a single cell of the grid. Initially, the robot is at coordinates (0, 0). A program has already been uploaded into the robot. The program is a sequence of instructions. Each instruction is one of the letters U, D, L, or R. These letters correspond to the commands ‘move up’, ‘move down’, ‘move left’, and ‘move right’ respectively. Once the robot is turned on, it will execute each instruction exactly once, in the given order. After executing all of the instructions, it will stop moving and it will turn itself off. You are given the robot’s current program in the string instructions. Whenever the robot returns to the cell (0, 0), it claps its hands. You find that funny, so you want to maximize the number of times the robot returns to the cell (0, 0). You are allowed to make at most changesAllowed modifications to the robot’s current program. Each modification consists of selecting a single character and changing it to a different character. (The new character still needs to be one of the letters U, D, L, or R. Note that you are not allowed to add or remove characters, you can only change the existing ones.) Please find and return the maximum number of times the robot can return to the cell (0, 0).
Definition

Class:
FriendlyRobot
Method:
findMaximumReturns
Parameters:
string, int
Returns:
int
Method signature:
int findMaximumReturns(string instructions, int changesAllowed)
(be sure your method is public)
Limits

Time limit (s):
2.000
Memory limit (MB):
256
Stack limit (MB):
256

Constraints

instructions will contain between 2 and 300 characters, inclusive.

Each character of instructions will be U, D, L, or R.

changesAllowed will be between 0 and the length of instructions, inclusive.
Examples
0)

“UULRRLLL”
1
Returns: 3
By changing the the first U to a D, you can make the robot return to its starting location 3 times. (Changing the second U to a D is also a valid solution.)
1)

“ULDR”
0
Returns: 1

2)

“ULDR”
2
Returns: 2

3)

“ULDRRLRUDUDLURLUDRUDL”
4
Returns: 8

4)

“LRLDRURDRDUDDDDRLLRUUDURURDRRDRULRDLLDDDDRLRRLLRRDDLRURLRULLLLLRRRDULRULULRLRDLLDDLLRDLUUDUURRULUDUDURULULLDRUDUUURRRURUULRLDLRRRDLLDLRDUULUURUDRURRLURLDLDDUUURRURRLRDLDDULLUDLUDULRDLDUURLUUUURRLRURRDLRRLLLRDRDUUUDRRRDLDRRUUDUDDUDDRLUDDULRURRDRUDLDLLLDLUDDRLURLDUDRUDDDDURLUUUDRLURDDDDLDDRDLUDDLDLURR”
47
Returns: 94

5)

“UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU”
300
Returns: 150

6)

“UD”
1
Returns: 1
Remember that you can change fewer than changesAllowed characters if you wish.

題意：

有一個機器人，從原點開始按照給定的操作移動，每次操作可以向上下左右中一個方向移動一格，現在可以改變k個操作，求機器人最多能經過原點幾次。

思路：

1.第一次想到的是把左移看做-1，右移+1，下移-400，上移+400，因為總步數不超過400，可以保證一個值表示一段確定的移動路線。然後就將問題轉化成求這個序列中修改k個值最多有多少個字首和為0。然而後面我做不出來了

2.接下來想到DP，f[i][j] 表示前i步，改變了j次，回到了原點，最多有幾次經過原點。注意回到了原點是很重要的條件，為了後面更新時不出錯。也可以說i為奇數的根本不用考慮，因為無論如何修改都不會走回原點。最開始寫DP的時候沒有考慮到f[i][j]走回原點這個條件，導致錯誤。具體操作：先預處理出不修改，走了前i步到的座標x[i]和y[i]，轉移方程為f [ i ] [ k ] = max ( f [ i ] [ k ] , f [ j ] [ k - ( abs ( x [ i ] - x [ j ] ) + abs ( y [ i ] - y [ j ] ) / 2 ) ] + 1 ) ( j < i && k <= changeAllowed && ( abs ( x [ i ] - x [ j ] ) + abs ( y [ i ] - y [ j ] ) ) %2 == 0 )

貼個程式碼，紀念一下我想了好久，調了半小時，不得不回寢室睡覺，又想了一晚上，早上起床才A掉的題目。然而jack表示這種題不是一下就A掉了嗎

#include <bits/stdc++.h>
using namespace std;
const int N = 310;
int n, x[N], y[N];
int f[N][N];

class FriendlyRobot {
public:
    int findMaximumReturns( string instructions, int changesAllowed );
};
int FriendlyRobot::findMaximumReturns(string instructions, int changesAllowed) {
    n = instructions.size();
    x[0] = y[0] = 0;
    for (int i = 1; i <= n; i++){
        x[i] = x[i-1];
        y[i] = y[i-1];
        if (instructions[i-1] == 'U') x[i]++;
        else if (instructions[i-1] == 'D') x[i]--;
        else if (instructions[i-1] == 'L') y[i]--;
        else y[i]++;
    }
    int ans = 0;
    memset(f, -1, sizeof(f));
    f[0][0] = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 0; j < i; j++){
            int ope = abs(x[i]-x[j])+abs(y[i]-y[j]);
            if (ope&1) continue;
            else ope >>= 1;
            for (int k = ope; k <= changesAllowed; k++){
                if (f[j][k-ope] == -1) continue;
                f[i][k] = max(f[i][k], f[j][k-ope]+1);
                ans = max(ans, f[i][k]);
            }
        }
    return ans;
}