Codeforces Round #658 (Div. 2)

Common Subsequence （手速）

判断 a，b 数组中是否有相同元素 

    int n,m,t;
    int i,j,k;
    map mp;
 
int main()
{
    //IOS;
    rush(){
        sdd(n,m);
        mp.clear();
        for(i=0;i

 

Sequential Nim （博弈论）

给出 n 堆石子，从序列号小的开始拿，序列号 i 的石子必须全部拿完，才可以继续拿 i+1 堆，问谁将最后一堆拿玩谁获胜

A B 两人博弈，只需要看看主动权在谁手里即可，A 先拿

找出第一个 >1 的数的位置即可

比如 1 1 2 1 1 3  

第一堆石子后，主动权在 B

第二堆石子后，主动权在 A

之后肯定 A 赢

A 将第三堆石子变为 1 ，B 只能将第三堆清空

到达最后一堆石子时，A 全拿

若变成 1 1 2 1 3

则 A 再拿第三堆石子时全拿，即可在最后一堆全部拿掉 

const int N=3e6+5;
 
    int n,m,t;
    int i,j,k;
    map mp;
    int a[N];
 
int main()
{
    //IOS;
    rush(){
        sd(n);
        int cur=0;
        bool flag=1;
        for(i=0;i

 

Prefix Flip (Hard Version)

有字符串 a，b，每次操作可以将字符串 a 的前缀反转

例如： 01111001，反转 3，前三个字符 011 -> 100 ->  001( 0 changes to 1 and 1 changes to 0 and reverse the order of the bits in the prefix.)

求多少次可以将 a 变为 b，不超过 2*n 次，n 为字符串长度

可以将字符串变为由一个字符构成 

遍历字符串，当 a[i] != a[i+1] 时，操作前缀 i，，比如 ：01111001：

a[1] != a[2] -> 11111001

a[5] != a[6] -> 00000001

a[7] != a[8] -> 11111111

b 同理

可以看出字符串取决于最后一个字符，若 a[n]!=b[n] 时,  字符串 a 要全部反转

但是题目中只要求操作 a

试想一下，假设 b 字符串经过 [2,3,5] 的操作后变为 a 字符串，想要恢复原字符串，需进行 [5,3,2] 才可实现

const int N=1e5+5;
 
    int n,m,t;
    int i,j,k;
    char a[N],b[N];
    vector va,vb;

int main()
{
    //IOS;
    rush(){
        sd(n);
        ss(a+1);
        ss(b+1);
        va.clear();
        vb.clear();
        for(i=1;i

D. Unmerge （01背包）

有 2*n 个数，判断能否等分成含 n 个元素的 a 数组，和含 n 个元素的 b 数组

a，b 数组满足递归条件：merge（a,b）

如果 a[1]>b[1] : 则递归  a[1]  { merge(a[2…n]  b) }

const int N=1e6+5;
 
    int n,m,t;
    int i,j,k;
    int a[N];
    int dp[N];
    vector v;//记录可能构成 a 数组的子序列长度

int main()
{
    //IOS;
    rush(){
        sd(n);
        for(i=1;i<=n+n;i++){
            sd(a[i]);
        }
        int cur=a[1];
        int cnt=1;
        v.clear();
        for(i=2;i<=n+n;i++){
            if(a[i]>cur){//比当前 a 数组中第一个大的数
                v.pb(cnt);
                cnt=1;
                cur=a[i];
            }
            else{
                cnt++;
            }
        }
        v.pb(cnt);
        sort(v.begin(),v.end());
        ms(dp,0);
        for(i=0;i=v[i];j--){
                dp[j]=max(dp[j],dp[j-v[i]]+v[i]);
            }
        }
        if(dp[n]==n) puts("YES");
        else puts("NO");
    }
    //PAUSE;
}