Codeforces Round #543 (Div. 2, based on Technocup 2019 Final Round)

A. Technogoblet of Fire

题意：n个人分别属于m个不同的学校 每个学校的最强者能够选中 黑客要使 k个他选中的可以稳被选 所以就为这k个人伪造学校 问最小需要伪造多少个

思路：记录每个学校都有哪些人 每次看黑客选中的人是不是在学校是最强者（这里要处理能力一样的情况，如果有能力一样的为了保证稳进也要伪造一个学校） 然后就是模拟了

 #include<bits/stdc++.h>
 #define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;i++)
 #define MS(arr,arr_value) memset(arr,arr_value,sizeof(arr))
 #define F first
 #define S second
 #define pii pair<int ,int >
 #define mkp make_pair
 #define pb push_back
 using namespace std;
 const int maxn=+;
 vector<pii>v[maxn];
 int p[maxn],s[maxn];

 int main(){
     int n,m,k;
     scanf("%d%d%d",&n,&m,&k);
     FOR(i,,n)scanf("%d",&p[i]);
     FOR(i,,n){
         scanf("%d",&s[i]);
         v[s[i]].pb(mkp(p[i],i));
     }
     int cnt=;
     int id;
     FOR(i,,k-){
         scanf("%d",&id);
         for(int j=;j<v[s[id]].size();j++){
             if(v[s[id]][j].F>=p[id]&&v[s[id]][j].S!=id){
                 cnt++;
                 break;
             }
         }
         for(int j=;j<v[s[id]].size();j++){
             if(v[s[id]][j]==mkp(p[id],s[id])){
                 v[s[id]].erase(v[s[id]].begin()+j);
                     break;
             }
         }
     }
     cout<<cnt<<endl;
     return ;
 }

B. Mike and Children

题意：给出N个数  每个数都不一样 两两组合 问使组合后的和相等的 最大对数是几

思路：因为每个数字都不一样 直接暴力枚举每个可能的值即可

 #include<bits/stdc++.h>
 #define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;i++)
 #define MS(arr,arr_value) memset(arr,arr_value,sizeof(arr))
 #define F first
 #define S second
 #define pii pair<int ,int >
 #define mkp make_pair
 #define pb push_back
 using namespace std;
 const int maxn=+;
 vector<pii>v[maxn];
 int a[maxn],s[maxn];
 set<int>q;
 map<int,int>mp;
 int main(){
     int n;
     scanf("%d",&n);
     FOR(i,,n-){scanf("%d",&a[i]);}
     int cnt=;
     int id=;
     FOR(i,,n-){
         FOR(j,i+,n-){
             q.insert(a[i]+a[j]);
             mp[a[i]+a[j]]++;
                 if(cnt<mp[a[i]+a[j]]){
                     cnt=mp[a[i]+a[j]];
                     id=a[i]+a[j];
                 }
         }
     }

     cout<<cnt<<endl;
 }

C. System Testing

题意：一秒测试一个样例 一共有m台机器和n个题目 给出每个题目的样例数  问存在多少个round(100*ok/n) ==当前测试到的样例数 ok是已经完成的题数

思路：这里刚开始写的时候是用优先队列模拟的，会出现一个bug 因为是并行计算的，所以当前最先完成测试的题目 测试到的样例 满足round(100*ok/n)==样例数 可能会出现在上上个题目之前（包含上上个）  这样就会统计不到

所以还是离散化秒数 用秒模拟即可（这题的数据范围是允许的） 参考了超哥的代码

 #include<bits/stdc++.h>
 #define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;i++)
 #define MS(arr,arr_value) memset(arr,arr_value,sizeof(arr))
 #define F first
 #define S second
 #define pii pair<int ,int >
 #define mkp make_pair
 #define pb push_back
 using namespace std;
 const int maxn=+;
 int vis[maxn],mk[maxn],p[maxn],a[maxn];
 int ans=;
 double ti=0.5;
 int main(){
     int n,k,m;
     scanf("%d%d",&n,&k);
     m=;
     int tmp;
     FOR(i,,n){
         scanf("%d",&a[i]);
     }
     k=min(n,k);
     FOR(i,,k)vis[i]=;
     for(;;ti+=){
         for(int i=;i<=n;i++){
             if(vis[i]==)p[i]++;
         }

     int d=round(100.0*m/n);

         for(int i=;i<=n;i++){
             if(vis[i]==&&p[i]==d&&!mk[i]){ans++;mk[i]=;}
         }

         for(int i=;i<=n;i++){
             if(p[i]==a[i]&&vis[i]==){
                 m++;
                 vis[i]=-;
                 for(int j=i+;j<=n;j++){
                     if(!vis[j]){vis[j]=;break;}
                 }
             }
         }
         if(m==n)break;
     }
     cout<<ans<<endl;
 return ;
 }

F. Compress String

把一个字符串包装成很多个连续的部分  单个字符串需要消耗a  如果    tl tl+1 ...tr是前面t1...tl-1的子序列只需要消耗b问最小代价

思路：维护一个最长公共子串详细见代码

 #include<bits/stdc++.h>
 #define FOR(i,f_start,f_end) for(int i=f_start;i<=f_end;i++)
 #define MS(arr,arr_value) memset(arr,arr_value,sizeof(arr))
 #define F first
 #define S second
 #define pii pair<int ,int >
 #define mkp make_pair
 #define pb push_back
 using namespace std;
 const int maxn=+;
 int dp[maxn];
 int lcs[maxn][maxn];
 char s[maxn];
 int main(){
     int n,a,b;
     scanf("%d%d%d",&n,&a,&b);
     scanf("%s",s+);
     FOR(i,,n){
         dp[i]=dp[i-]+a;//初始化删一个
         FOR(j,,i-){
         if(s[i]==s[j])lcs[i][j]=lcs[i-][j-]+;// 维护前i个和前j的最长公共子串并且终点是在i的
         if(lcs[i][j]!=&&i-j>=lcs[i][j])dp[i]=min(dp[i],dp[i-lcs[i][j]]+b);//如果1-i,1-j存在公共子串其中一个终点在i并且大区间（也就是终点的i）的起点在小区间的前面 即可更新dp[i][j] 可画图理解其正确性
         }
     }
     cout<<dp[n]<<endl;
     return ;
 }