SDUT 2021 Winter Team Contest - 3（Gym 101669）

题目链接

A - Concerts

题意：

有 26 种演唱会，John 希望按照某个顺序看某些类型的演唱会，但是看完某种类型的演唱会后需要至少休息一定的天数才能继续看演唱会，问有多少种看演唱会的方案

思路：

dp求解

答案：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
#include <stack>
#include <cmath>
#include <map>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
#define ll long long
#define mem(f,x) memset(f,x,sizeof(f));
#define sca(x) scanf("%d",&x);
#define scl(x) scanf("%lld",&x);
#define sca2(x,y) scanf("%d %d",&x,&y);
#define sca3(x,y,z) scanf("%d %d %d",&x,&y,&z);
#define pu puts("");
#define pri(x) printf("%d\n",x);
#define mp make_pair
#define pb push_back
const int MAX=1061109567;
const int N =500010,M=5000100;
const int maxn = 1e5+100;
const int mod = 1e9+7;
char arr[10010], brr[maxn];
long long dp[2][maxn];
int ad[30], n, k;
void solve() {
    sca2(k,n);
    for(int i=0;i<26;i++) {
        sca(ad[i]);
    }
    for(int i=0;i<=n;i++) {
        dp[0][i] = 1;
    }
    scanf("%s", arr+1);
    scanf("%s", brr+1);
}
int main() {
    solve();
    int pos = 0;
    for(int i=1;i<=k;i++) {
        dp[pos^=1][0] = 0;
        for(int j=1;j<=n;j++) {
            dp[pos][j] = dp[pos][j-1];
            if(arr[i] == brr[j] && j-1-ad[arr[i-1] - 'A'] >= 0)
                dp[pos][j] += dp[pos^1][j-1-ad[arr[i-1]-'A']];
            dp[pos][j] %= mod;
        }
    }
    printf("%lld", dp[pos][n]);
    return 0;
}

D - Harry Potter and The Vector Spell

题意：

求一个01矩阵的秩，这个矩阵的每一列只有两个1

思路：

对于每一列的两个一所在的行连边，最后形成一个图，最后的秩肯定是这个图最大的一个无环子图，其实就是最小生成树。

答案：

#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eps 1e-6
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int M = 5e3 + 10;
using namespace std;

int n,m;
int ans;
vector<int>dp[N];
int vis[N];

int Find(int k){
    if(vis[k]!=k) vis[k]=Find(vis[k]);
    return vis[k];
}

void solve(){;
    cin>>m>>n;
    int k;
    rep(i,1,m){
        cin>>k;
        int x;
        while(k--){
            cin>>x;
            dp[x].pb(i);
        }
    }
    rep(i,1,m){
        vis[i]=i;
    }
    rep(i,1,n){
        int u=dp[i][0];
        int v=dp[i][1];
        int x=Find(u);
        int y=Find(v);
        if(x!=y){
            ans++;
            vis[x]=y;
        }
    }
    cout<<ans<<endl;
}

int main()
{
    solve();
    return 0;
}

F - Binary Transformations

（补题，思路来源于其他大佬）

题意：

把a串变为b串
每次改变一位的代价是改变后所有为1的位的代价总和
很简单的贪心
先把1变成0再把0变成1显然是代价最小
并且在1变0的时候优先变价值大的
在0变1的时候优先变价值小的

思路：

把a[i] = 1 && b[i] = 1的位先变成0后变成1
可以很显然把这样的情况归并进1变0和0变1两次情况

考虑到要排序并且要插入
很自然想到可以用set
（代码比较短但是时间复杂度好像高一点）
因为数据范围比较小所以就可以n方过题
于是就考虑枚举要进行1变0再变1的操作个数
因为贪心思想肯定优先变大的
所以排了个序

答案：

#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define rep(i,a,b) for(auto i=a;i<=b;++i)
#define bep(i,a,b) for(auto i=a;i>=b;--i)
#define lowbit(x) x&(-x)
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define PI acos(-1)
#define pb push_back
#define eps 1e-6
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int M = 5e3 + 10;
using namespace std;

int n;
int a[N];
string s1;
string s2;
vector<int>vp;
multiset<int>mp1;
multiset<int>mp2;
ll sum;

bool cmp(int x,int y){
    return x>y;
}

void solve(){;
    cin>>n;
    rep(i,0,n-1){
        cin>>a[i];
    }
    cin>>s1;
    cin>>s2;
    rep(i,0,n-1){
        if(s1[i]=='1'&&s2[i]=='1') vp.pb(a[i]);
        else if(s1[i]=='1'&&s2[i]=='0') mp1.insert(a[i]);
        else if(s1[i]=='0'&&s2[i]=='1') mp2.insert(a[i]);
        if(s1[i]=='1') sum+=(ll)a[i];
    }
    sort(vp.begin(),vp.end(),cmp);
    int len=vp.size();
    ll ans=INF;
    multiset<int>::iterator it1;
    multiset<int>::reverse_iterator it2;
    rep(i,0,len){
        ll cnt=sum;
        ll res=0;
        if(i){
            mp1.insert(vp[i-1]);
            mp2.insert(vp[i-1]);
        }
        for(it2=mp1.rbegin();it2!=mp1.rend();it2++){
            cnt-=(*it2);
            res+=cnt;
        }
        for(it1=mp2.begin();it1!=mp2.end();it1++){
            cnt+=(*it1);
            res+=cnt;
        }
        ans=min(res,ans);
    }
    cout<<ans<<endl;
}

int main()
{
    solve();
    return 0;
}

G - Robots

题意：

有 n 次加速，每次加速的加速度和加速时间都给出，问重排加速后的经过的最大位移和当前顺序加速后的位移的差。

思路：

按照加速度排序以后就能得到最大位移

答案：

#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define pb push_back
#define eps 1e-6
const int mod = 1e9 + 7;
const int N = 1e4 + 10;
const int M = 111;
using namespace std;

struct node{
    double a;
    double t;
}dp[N];

int n;

bool cmp(node x,node y){
    return x.a>y.a;
}

double Get_len(){
    double x=0;
    double v=0;
    for(int i=0;i<n;i++){
        x+=(2*v+dp[i].a*dp[i].t)*dp[i].t/2;
        v+=dp[i].a*dp[i].t;
    }
    return x;
}

void solve(){
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>dp[i].a>>dp[i].t;
    }
    double x1=Get_len();
    sort(dp,dp+n,cmp);
    double x2=Get_len();
    printf("%.1f\n",x2-x1);
}

int main()
{
    solve();
    return 0;
}

J - Cunning Friends

题意：

n堆石子，三个人轮流选一堆拿若干个，后两个人都想让先手输，问先手最后是否能赢。

思路：

1. 全是1的时候，n如果能整除3，那么必输，否则必赢

2. 只有一个不是1的时候 ，如果n%3 == 0 ，就把不是1的取成1，这样对于第二个人必输，如果 n%3 == 1||n%3 == 2 取走不是1的一堆必赢

3. 如果有小于n-2 个1，那么根据nim博弈，后面两个人总是能轻松的转移到任何状态，这时候 第一个人必输

4. 通过上面的讨论我们n%3 是一个必输态，我们必须避免这种状态

5. 如果有n-2个1，剩下至少有一个2，

6. 如果 n% 3 == 0 ，我们把 最后一堆取的只剩下一个，这样剩下的状态等价于 n % 3 == 1,如果 取走一个2的堆或这一个1的堆，都不能改变n%3 == 1，如果取走2的堆里面的一个，那么这样就是 n%3 == 2 的状态还是必赢如果 n% 3 == 0 ，我们把 最后一堆取的只剩下一个，这样剩下的状态等价于 n % 3 == 1,如果 取走一个2的堆或这一个1的堆，都不能改变n%3 == 1，如果取走2的堆里面的一个，那么这样就是 n%3 == 2 的状态还是必赢

7. 如果 n% 3 == 1,那么我们把最后一个取完，这样剩下两个人可以把状态改变成 n%3 == 2，或者保持n% 3==1这样都是必胜态

8. 如果 n% 3 == 2，无论怎么取，剩下一个人都可以转化成n%3 == 0

答案：

#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define pb push_back
#define eps 1e-6
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int M = 311;
using namespace std;

int n;

bool judge(int sum1,int sum2){
    if(sum1==n) return (n%3!=0);
    if(sum1==n-1) return true;
    if(sum1<n-2) return false;
    if(n%3!=2&&sum2) return true;
    return false;
}

void solve(){;
    cin>>n;
    int sum1=0;
    int sum2=0;
    for(int i=1;i<=n;i++){
        int k;
        cin>>k;
        if(k==1) sum1++;
        else if(k==2) sum2++;
    }
    if(judge(sum1,sum2)) puts("Win");
    else puts("Lose");
}

int main()
{
    solve();
    return 0;
}

K - Escape Room

题意：

给你n个数ai，分别代表以i开始到第n个数的最长递增子序列为ai，要求你构造出这么一个字典序最小的序列。

思路：

对于每一个ai为结尾求一个最长递增，则构造的该位为当前第几大，而且要倒着构造，因为复杂度原因不可行。最后在学长的教导下才知道正解，由ai的大小倒着构造，ai最大的数赋值最大，相同的时候按位置顺序赋值。

答案：

#include <iostream>
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define INF 0x3f3f3f3f3f3f3f3f
#define PII pair<int,int>
#define PLL pair<ll,ll>
#define pb push_back
#define eps 1e-6
const int mod = 7;
const int N = 1e4 + 10;
const int M = 111;
using namespace std;

struct node{
    int id;
    int sum;
    int key;
};

vector<node>vp;

bool cmp(node x,node y){
    if(x.sum!=y.sum) return x.sum<y.sum;
    return x.id<y.id;
}

bool cmp1(node x,node y){
    return x.id<y.id;
}

void solve(){
    int n;
    cin>>n;
    node pos;
    for(int i=0;i<n;i++){
        cin>>pos.sum;
        pos.id=i;
        vp.pb(pos);
    }
    sort(vp.begin(),vp.end(),cmp);
    for(int i=0;i<n;i++){
        vp[i].key=n-i;
    }
    sort(vp.begin(),vp.end(),cmp1);
    for(int i=0;i<n;i++){
        if(i==n-1) cout<<vp[i].key<<endl;
        else cout<<vp[i].key<<" ";
    }
}

int main()
{
    solve();
    return 0;
}