• codeforces刷题一

    C. Removing Smallest Multiples

    难度1200

    题意：给定一个串S和一个串T S串是{1,2，......，n}的数 而T串是输入的 现在要使得S串变为T串的

    最小花费 删除操作是删除k的最小倍数的数   花费的定义为k的总和

    思路 直接用 i 枚举 1 - n 然后用这个数 i 去把1-n中 i 的所有连续倍数要删的数都删掉 这样的花费一定是最小的

    细节 0表示要删的 1表示不用删的 2表示已经删了的

    代码

    1. #include 
    2. typedef long long ll;
    3.  
    4. using namespace std;
    5.  
    6. int vis[1000007];
    7. bool solve()
    8. {
    9.     int n;
    10.     cin >> n;
    11.     for (int i = 1;i <= n;i++)
    12.     {
    13.         char c;
    14.         cin >> c;
    15.         vis[i] = c == '1';
    16.     }
    17.     ll sum = 0;
    18.     for (int i = 1;i <= n;i++)
    19.     {
    20.         if (vis[i] == 1) continue;
    21.         for (int j = i;j <= n;j += i)
    22.         {
    23.             if (vis[j] == 1) break;
    24.             if (vis[j] == 0)
    25.             {
    26.                 vis[j] = 2;
    27.                 sum += i;
    28.             }
    29.         }
    30.     }
    31.     cout << sum << '\n';
    32.     return true;
    33. }
    34.  
    35. int main() {
    36.     std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    37.     int t = 1;
    38.     cin >> t;
    39.     while (t--)
    40.     {
    41.         if (!solve()) cout << -1 << '\n';
    42.     }
    43.     return 0;
    44. }

    C. Complementary XOR

    难度1400

    题意：给定a b二进制串 然后每次操作都可以选择一个 l 和 r 然后a串[ l , r ]区间的数取反 b串的[1,l-1]和[ r+1,n ]区间取反 问a和b能不能同时变为00000...  输出操作数和每次的操作区间

    思路：我们可以从末状态开始操作看看能操作到什么样的状态 可以发现 操作奇数次的时候 可以发现a b 的每一位都不相同 操作偶数次的时候 可以发现a b 的每一位都是相同的 那么有解的情况就一定是每一位都相同或者每一位都不同 那么我们只需要构造出一组操作步数小于等于n+5的 方案即为答案

    构造方法（只判断一定有解的情况）

    首先先把a全部变为0 这需要的操作步数最多是n 然后b只有两种状态 要么全0要么全1 如果是全0就不用操作了 如果是全1 那么就先操作[ 1,n ]先把a全部全为1 再操作[ 1,1 ] 将a1变为0 b[2,n]变为0 最后操作[ 2,n ] 将a[ 2,n ]操作为全0 b1操作为0 这时候就是全0了 操作步数最多是n+3 合法

    1. #include 
    2. using namespace std;
    3. typedef pair<int,int> PII;
    4. const int N=2e5+10;
    5. int a[N],b[N];
    6. void solve()
    7. {
    8.     int n;
    9.     cin>>n;
    10.     for(int i=1;i<=n;i++)
    11.     {
    12.         char c;
    13.         cin>>c;
    14.         a[i]=c-'0';
    15.     }
    16.     int cnt=0;
    17.     for(int i=1;i<=n;i++)
    18.     {
    19.         char c;
    20.         cin>>c;
    21.         b[i]=c-'0';
    22.         cnt+=(b[i]==a[i]);
    23.     }
    24.     if(cnt!=n&&cnt!=0)
    25.     {
    26.         cout<<"NO"<
    27.         return ;
    28.     }
    29.     bool fl;
    30.     if(cnt==n)
    31.         fl=0;
    32.     else fl=1;
    33.     vector ans;
    34.     for(int i=1;i<=n;i++)
    35.     {
    36.         if(a[i]==0) continue;
    37.         int j=i;
    38.         while(j+1<=n&&a[j+1]==1) j++;
    39.         ans.push_back({i,j});
    40.         fl^=1;
    41.         i=j;
    42.     }
    43.     if(fl)
    44.     {
    45.         ans.push_back({1,n});
    46.         ans.push_back({1,1});
    47.         ans.push_back({2,n});
    48.     }
    49.         cout<<"YES"<
    50.         cout<size()<
    51.         for(auto [x, y]:ans) cout<' '<
    52. }
    53. int main()
    54. {
    55.     int t;
    56.     cin>>t;
    57.     while(t--)
    58.         solve();
    59.     return 0;
    60. }

    C. Parity Shuffle Sorting

    难度1300

    题意：给定一个串经过一些操作变为不减的串 可以证明一定有解

            操作：选择一个l和r  如果 al + ar 为奇数 让ar = al  如果是偶数 让al=ar

    思路： 虽然有很多种可能性 但是是不是有一种可能可以使得所有元素都变成相同元素从而构造一个合法解呢？

    答案是肯定可以的 然后应该把整个序列变成哪个元素呢？那么是不是应该去看看是不是首尾元素的其中一个呢？因为操作是把某个元素变为前面一个元素或者后面一个元素 那么简单一点想 肯定是首尾元素的 那么我们用a[1]代表首元素 a[n]代表尾元素

    构造方法：

    1.如果a[1]是偶数 a[n]也为偶数 由于偶数加偶数一定等于偶数并且相加如果是偶数 就让al=ar也就是前面的等于后面的 那么就可以把 1- (n-1)中的所有偶数都变为a[n] 然后a[1]=a[n]也是偶数并且相加为奇数 让ar = al 也就是后面等于前面 那么就可以把 2 - (n-1)的所有奇数都可以变为a[n]了

    2.如果a[1]为奇数 a[n]为奇数 由于奇数加奇数一定为偶数 并且如果是奇数 就让al=ar 那么就是让1-(n-1)中的所有奇数都变为a[n]了 然后这时候a[1]=a[n]为一个奇数 然后奇数加偶数为奇数 如果 相加为奇数 让ar = al 那么就可以让 2-(n-1)的所有数变为a[1]=a[n]

    3.如果a[1]为奇数 a[n]为偶数 由于奇数加偶数为奇数 那么就先让a[n]=a[1] 然后两个都为奇数了 就转换为第二种情况了

    4.如果a[1]为偶数 a[n]为奇数 由于奇数加偶数为奇数 那么就让 a[n]=a[1]就转换为第一种情况了

    这时候所有情况都枚举完了 就可以做了

    由于不限制怎么交换 交换多少次 所以怎么样都ok的 就算重复操作也没问题

    实现代码 （我这里样例输出都是重复的 如果不想用可以用上面思路再写一份）

    1. #include 
    2. using namespace std;
    3. const int N=1e5+10;
    4. int a[N];
    5. void solve()
    6. {
    7.     int n;
    8.     cin>>n;
    9.     for(int i=1;i<=n;i++)
    10.     {
    11.         cin>>a[i];
    12.     }
    13.     vectorint,int>> ans;
    14.     if(a[1]%2==0&&a[n]%2==0)
    15.     {
    16.         for(int i=1;i<=n-1;i++)
    17.             if(a[i]%2==0)
    18.             ans.push_back({i,n});
    19.             else
    20.             ans.push_back({1,i});
    21.     }
    22.     else if(a[1]%2==1&&a[n]%2==1)
    23.     {
    24.         for(int i=1;i<=n-1;i++)
    25.             if(a[i]%2==1)
    26.             ans.push_back({i,n});
    27.             else
    28.             ans.push_back({1,i});
    29.     }
    30.     else if(a[1]%2==1&&a[n]%2==0)
    31.     {
    32.         ans.push_back({1,n});
    33.         for(int i=1;i<=n-1;i++)
    34.             if(a[i]%2==1)
    35.             ans.push_back({i,n});
    36.             else
    37.             ans.push_back({1,i});
    38.     }
    39.     else
    40.     {
    41.         ans.push_back({1,n});
    42.         for(int i=1;i<=n-1;i++)
    43.             if(a[i]%2==0)
    44.             ans.push_back({i,n});
    45.             else
    46.             ans.push_back({1,i});
    47.     }
    48.     cout<size()<
    49.     if(ans.size())
    50.     {
    51.         for(int i=0;isize();i++)
    52.             cout<" "<
    53.     }
    54. }
    55. int main()
    56. {
    57.     int t;
    58.     cin>>t;
    59.     while(t--)
    60.         solve();
    61.     return 0;
    62. }

    C. Even Number Addicts

    难度1500

    题意：博弈游戏 给定一个序列 然后每一个回合都可以删一个数 删到没有数时游戏结束 然后如果Alice删的数总和为偶数的话Alice赢 否则bob赢 Ailce先手

    思路：这里是看了某位贴吧大佬的题解

    首先我们可以发现很重要的一点就是：偶数不会影响Alice手中的数的奇偶性的改变。一个奇数可以改变一次，我们可以按照这个结论去找突破口。

    很多人的第一感觉是看奇数的奇偶来找结论，我们先随便试一试几组样例：

    我们首先去找一下答案和奇数的什么有关。我们先看样例，1 3 5 7显然这时候Alice一定能拿到两个奇数。但是如果是1 3，这时候Alice就只能拿到一个，所以就输了。假如存在1 3 5 8，这时候Alice必胜，但是1 2 4 6 8的话，Alice就会输掉。

    我们可以感觉到，只获得奇数数量的奇偶性是不够的，我们发现% 4 = 0 / 1 / 2 / 3 答案都有可能不同。

    我们发现，每多4个奇数或者4个偶数，是不会影响结果的。因此，影响结果的数是刚开始的n和奇数数量 % 4。对于一个人来说 看是否是偶数的话就是%2 但是现在是两个人 那么就会乘2 变为%4 

    我是这样理解的

    分类四种情况讨论：

    奇数 % 4 == 0 ：

    先手必胜，因为不管怎么拿先手都能拿到两两一组的奇数使得相加变成偶数。

    奇数 % 4 == 1 ：

    如果n是偶数，那么先手必胜，否则先手必败。 简单来说，我们可以把这个情况看成1 2 4 8和1 2 4 6 8这两个样例。1248是先手必胜，因为Alice只要不拿到那个奇数，并且他是第一个拿的，所以一定可以把这个奇数留给Bob。 12468的话刚好多了一个奇数，因此两人都不想拿这个奇数，所以最后一定剩给Alice。

    奇数 % 4 == 2 :

    先手必败，因为先手必然会拿到一个奇数，不能和另一个奇数配对。

    奇数 % 4 == 3 ：

    先手必胜，因为先手必然会可以在三个奇数中拿到2个，直接获得胜利。

    代码

    1. #include 
    2. #define NO cout<<"Bob"<
    3. #define YES cout<<"Alice"<
    4. using namespace std;
    5. const int N=1e5+10;
    6. int a[N];
    7. int n;
    8. void solve()
    9. {
    10.     cin >> n;
    11.     int zero = 0, one = 0;
    12.     for(int i = 1 ; i <= n ; i ++ ) cin >> a[i], zero += (!(a[i] & 1)), one += (a[i] & 1);
    13.     if(!one) {YES;}
    14.     else if(one & 1)
    15.     {
    16.         if(one % 4 == 1) {
    17.             if(n & 1) {NO;}
    18.             else {YES;}
    19.         }
    20.         else if(one % 4 == 3) {YES;}
    21.     }
    22.     else{
    23.         if(one % 4 == 0) {YES;}
    24.         else {NO;}
    25.     }
    26. }
    27. int main()
    28. {
    29.     int t;
    30.     cin>>t;
    31.     while(t--)
    32.         solve();
    33.     return 0;
    34. }

    本题还有dp解法 记忆化搜

    1. int dfs(int x, int y, int cur, int turn) {
    2.     int &v = f[x][y][cur][turn];
    3.     if(~v) return v;
    4.     if(!x && !y) return !cur ^ turn;
    5.     int res = 0;
    6.     if(x) res |= !dfs(x - 1, y, cur, !turn);
    7.     if(y) res |= !dfs(x, y - 1, cur ^ !turn, !turn);
    8.     return v = res;
    9. }

     

  • 相关阅读:
    Linux安装GitLab的两种方式（SSH和Docker）
    van-calendar 实现移动端日历效果
    生成的二维码如何解析出原来的地址？
    centos7中卸载Java、jdk命令
    Dubbo 架构介绍
    算法---不同路径(Kotlin)
    ASEMI-KBL410是什么元器件，kbl410整流桥参数
    一百八十、Linux——服务器时间比实际时间快2分钟
    springboot停车场车辆定位管理可视化分析系统的设计与实现毕业设计源码101702
    Ubuntu 20.04上安装Datalog Disassembly工具的过程
  • 原文地址：https://blog.csdn.net/lee_14141/article/details/127863671