2019上海高校程序设计竞赛

这次比赛给人的体验怎么说呢，因为是个人赛，所以感觉大多数时候都比较沉闷，然后因为自身水平的严重不足以及榜单的问题，一些其实并不是很难的题也没有做出来，时间基本上全部交给G和E两道题了。后面的几道题也比较难，还涉及了一些没学上的知识点。

C-CSL 的密码

要求有多少个长度不小于m的本质不同的字符串。据说现场不少人是用SA或者SAM过的。然后这道题其实是因为每个字符串都是随机生成的，当长度比较长的时候，两个字符串相同的概率是非常小的。所以只要当m比较大的时候直接输出方案数就可以了，m比较小的时候只要枚举用一个set维护就好了。（不会SA也不会SAM的萌新qwq…

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
set<string> s;
int main() {
    int n,m;
    ll ans=0;
    string str;
    cin>>n>>m>>str;
    if(m>=15) {
        for(int i=m;i<=n;i++)
            ans+=n-i+1;
    }
    else {
        for(int i=m;i<15;i++)
            for(int j=0;j+i-1<n;j++)
                s.insert(str.substr(j,i));
        for(int i=15;i<=n;i++)
            ans+=n-i+1;
        ans+=s.size();
    }
    printf("%lld\n",ans);
    return 0;
}

D-CSL的字符串

这道题是说你要原字符串的一些字符删除掉，然后使得里面所有的字符都只出现一次，而且如果有多种方案的话，选择那个最小的输出。用一个单调栈维护答案。对于当前没有被标记过的字符，如果现在字符串末尾的字符是大于进入的字符并且这个字符后面还有的话，就先删掉末尾字符，最后再加入新的字符。最终得到就是答案。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
int main() {
    string s,ans;
    map<char,int> mp;
    set<char> vis;
    cin>>s;
    for(int i=0;i<s.size();i++) mp[s[i]]++;
    for(int i=0;i<s.size();i++) {
        if(!vis.count(s[i])) {
            while(!ans.empty()&&ans.back()>s[i]&&mp[ans.back()]>0)
                vis.erase(vis.find(ans.back())),ans.pop_back();
            ans+=s[i],vis.insert(s[i]);
        }
        mp[s[i]]--;
    }
    cout<<ans<<endl;
    return 0;
}

E-CSL的魔法

场上花了很久做了这道题，其实这个在之前就以及遇到过，但是当时一直没搞清楚。是说给出了两个序列，然后让你任意交换这两个数组。使得最后这两个数组对应乘积和最小。排序不等式告诉我们，显然这个应该是倒序的时候是最小的。然后我们只要记录一下每个数组的id，分别对他们由大到小排序和由小到大排序。排好之后记录下是第几大，然后再排回来。这时候就有了一个对应的关系，建边之后找环。每有一个环就可以少交换一次。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=1e5+50;
struct node{ int rk,id;}a[N],b[N];
vector<int> G[N];
bool cmp1(node x,node y) { return x.rk<y.rk; }
bool cmp2(node x,node y) { return x.rk>y.rk; }
bool cmp(node x,node y) { return x.id<y.id; }
void add(int u,int v) { G[u].push_back(v); }
int cnt=0;
bool vis[N];
void dfs(int u) {
    if(vis[u]) {
        ++cnt;
        return;
    }
    vis[u]=true;
    for(auto &v:G[u]) dfs(v);
}
int main() {
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&a[i].rk),a[i].id=i;
    for(int i=1;i<=n;i++) scanf("%d",&b[i].rk),b[i].id=i;
    sort(a+1,a+n+1,cmp1);
    sort(b+1,b+n+1,cmp2);
    for(int i=1;i<=n;i++) a[i].rk=i;
    for(int i=1;i<=n;i++) b[i].rk=i;
    sort(a+1,a+n+1,cmp);
    sort(b+1,b+n+1,cmp);
    for(int i=1;i<=n;i++) add(a[i].rk,b[i].rk);
    for(int i=1;i<=n;i++) {
        if(!vis[i]) dfs(i);
    }
    printf("%d\n",n-cnt);
    return 0;
}

F-CSL的神奇序列

给出一个数列并且它的前n项卷积始终都为$w^2$，告诉你第一项是$w_0=w$，让你求出这个数列的任意一项$2^{n}n!a_n$是多少，直接找规律然后预处理一遍输出就可以了。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const ll mod=998244353;
const int N=1e6+50;
ll f[N];
int main() {
    int w,q;
    scanf("%d%d",&w,&q);
    f[1]=w;
    for(int i=2;i<=(int)1e6;i++) {
        f[i]=f[i-1]*(2*i-1);
        f[i]%=mod;
    }
    while(q--) {
        int x;
        scanf("%d",&x);
        printf("%lld\n",f[x]);
    }
    return 0;
}

G-CSL的训练计划

题目的意思其实就是给出一个有向图，然后出边的那个点的权值至少是前驱结点的a+k*w这么多，然后问这个k的最大值是多少，能够让所有的点的权值之和不超过s,一开始首先想到的是二分，但是二分过不了。后来想到这道题其实不需要二分，首先一开始入度为0的点权值是0，然后拓扑排序，求出最后的和。如果和为0的话，那么就是无限大，否则直接输出s/sum就可以了。差不多是一个裸的拓扑排序题。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=2e5+50;
int n,m,in[N],IN[N];
ll dp[N];
ll s;
struct edge{ int v; ll w; };
vector<edge>G[N];
int main() {
    scanf("%d%d%lld",&n,&m,&s);
    for(int i=1;i<=m;i++) {
        int u,v;ll w;
        scanf("%d%d%lld",&u,&v,&w);
        G[u].push_back({v,w});
        in[v]++;
    }
    queue<int> q;
    for(int i=1;i<=n;i++) {
        if(!in[i]) q.push(i),dp[i]=0;
    }
    while(!q.empty()){
        int u=q.front();q.pop();
        for(auto &e:G[u]) {
            int v=e.v;
            ll w=e.w;
            dp[v]=max(dp[v],dp[u]+w);
            in[v]--;
            if(in[v]==0) q.push(v);
        }
    }
    ll sum=0;
    for(int i=1;i<=n;i++) sum+=dp[i];
    if(sum==0) printf("-1");
    else printf("%lld\n",s/sum);
    return 0;
}

H-CSL的拼图

这题是说给出一个n维空间，然后要把这里面所有的点全部还原，问操作T次是否可以实现这个事情。然后这里和E题略有不同的就是这里是个n维点对。由于这里维度乘积最大不超过1e6。直接把每个点都哈希一遍，把这个n维点对当作每一位都是d[i]进制就好了。哈希完了之后再连边找环，这里还是一样的做法。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=1e6+50;
int d[15],a[N],b[N],c[N];
vector<int> G[N];
int loop=0;
bool vis[N];
void add(int u,int v) { G[u].push_back(v); }
void dfs(int u) {
    if(vis[u]) {
        ++loop;
        return;
    }
    vis[u]=1;
    for(auto &v:G[u]) dfs(v);
}
int main() {
    int n,mul=1;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) scanf("%d",&d[i]),mul*=d[i];
    for(int i=1;i<=mul;i++) {
        for(int j=1;j<=n;j++) {
            scanf("%d",&c[j]);
            a[i]=a[i]*d[j]+c[j]-1;
        }
        a[i]++;
        for(int j=1;j<=n;j++) {
            scanf("%d",&c[j]);
            b[a[i]]=b[a[i]]*d[j]+c[j]-1;
        }
        b[a[i]]++;
    }
    int t;
    scanf("%d",&t);
    for(int i=1;i<=mul;i++) add(i,b[i]);
    for(int i=1;i<=mul;i++) {
        if(!vis[i]) {
            dfs(i);
        }
    }
    int ans=mul-loop;
  //  printf("%d\n",ans);
    if(t>=ans&&(t-ans)%2==0) printf("YES\n");
    else printf("NO\n");
    return 0;
}

后续的题之后再接着补。