cf*3 总结与反思

C. Hamiltonian Wall

题目大意：
两行n列字符串，只包含‘B’，‘W’，其中每一列至少有一个‘B’。问能否有序的将所有‘
B‘访问。

解题思路： 对于每个列，最多有三种情况，两个’B’，第一行‘B’，第二行‘B’。可以根据前面的情况，去判定当前的能否全部访问，要特判第一列。

char ph[3][N];
int dp[3][N];
void solve() {
    memset(ph, 0, sizeof(ph));
    memset(dp, 0, sizeof(dp));
    int n; cin>>n;
    rep(i,1,2) cin>> ph[i] + 1; // 读入每一行

    // 特判第一列的情况
    bool r1 = 0, r2 = 0; 
    r1 = ph[1][1] == 'B' ? 1 : 0;
    r2 = ph[2][1] == 'B' ? 1 : 0;
    if(r1 && r2) {
        dp[1][1] = dp[2][1] = 3;
    } else if(r1) {
        dp[1][1] = dp[2][1] = 1;
    } else {
        dp[2][1] = dp[1][1] = 2;
    }

    rep(i,2,n) {
        r1 = ph[1][i] == 'B' ? 1 : 0; r2 = ph[2][i] == 'B' ? 1 : 0;

        // 当前列有两个‘B’
        if(r1 && r2) {
            if(dp[1][i-1] == 3) { // 前一列也是两个‘B’
                dp[1][i] = dp[2][i] = 3;
            } else if(dp[1][i- 1] == 2) { // 前一列一个‘B’，且在第二行
                dp[1][i] = dp[2][i] = 1;
            } else if(dp[1][i-1] == 1) { // 在第一行
                dp[1][i] = dp[2][i] = 2;
            }
        } else if(r1) { // 当前列第一行有‘B’
            if(dp[1][i-1] == 2) { // 前一个在第二行有‘B’
                // no
                puts("NO");
                return ;
            } else {
                dp[1][i] = dp[2][i] = 1;
            }
        } else if(r2) { // 当前列第二行有’B‘
            if(dp[1][i-1] == 1) { // 前一列在第一行有’B‘
                // no
                puts("NO");
                return ;
            } else {
                dp[1][i] = dp[2][i] = 2;
            }
        } else {
            ;
        }
    }
    puts("YES");
}

C. Ice and Fire

题目大意：
一个n-1的01字符串，有n个玩家，第i个玩家价值为i。字符为’1‘，表示，价值大的玩家赢，为’0‘，则表示价值小的赢。在前x个回合中，得到每个可以赢得人数。

解题思路： 每一次’0‘，’1‘前后的不同，都会让答案带来多样性。连续的’1‘，’0‘会减少答案个数。记录‘0’，’1’出现次数，前后不同时候将次数都清空。用当前进行回合x减去‘1’，‘0’最大值可以得到当前前x回合胜利个数。

void solve() {
    int n; cin>>n;
    string str; cin>>str;

    int zero = 0, one = 0;
    rep(i,0,n-2) {
        if(str[i] == '1') one++;
        else zero ++;
        // 前一个回合为1，
        // 前后不一样，多样性最大，为i+1
        if(!i || str[i] != str[i-1]) zero = one = 0;
        // 最大值表示 连续有多少个‘0’，‘1’，就有max - 1 的玩家不会胜利。
        cout<<i - max(zero, one) + 1<<" ";
    }
    puts("");
}

C. Schedule Management

题目大意：
n个工人m个任务。m个任务分配给n个工人，每个工人工作互不干扰。同时每个任务有最熟练它的工人。对于每个任务，熟悉的工人完成需要1小时，不熟悉的工人则需要2小时。
解题思路： 二分。求工人熟悉的任务完成程度，记录在熟悉任务完成后还可以接多少个非熟悉任务 和 完不成熟悉任务人数。

int a[N];
int n;
bool check(int mid) {
    // ls 可额外做的非熟悉任务个数
    // fs 该工人熟悉任务做不完个数
    LL ls = 0, fs = 0;
    rep(i,1,n) {
        if(mid >= a[i]) {
            ls += (mid - a[i]) >> 1;
        } else {
            fs += a[i] - mid;
        }
    }
    // 
    return ls >= fs;
}
void solve() {
    memset(a, 0, sizeof(a));
    int m; cin>>n>>m;
    rep(i,1,m) {
        int b; cin>>b; a[b]++;
    }
    int ans = 0;
    // 二分答案
    int le = 0, ri = 1e9;
    while(le <= ri) {
        int mid = le + ri >> 1;
        if(check(mid)) {
            ans = mid;
            ri = mid - 1;
        } else {
            le = mid + 1;
        }
    }
    cout<<ans<<endl;
}

总结

程序出错，看一遍程序，没找到问题，看看是不是数组溢出了。数组溢出真难找。
思维题还是要多做，不然碰到没有头绪的题，无从下手。同时记得多想多实践多碰idea。
感觉除了做cf题，也要多看看自己的算法板子，防止算法题对数据结构还有一些算法忘了或不熟悉导致没想到正确思路、逻辑。
寒假还应该每天定制目标，感觉没动力。
加油！！！