SMU Summer 2024 Contest Round 3

反思：打字很慢，速度太慢了，这次整体较上次较好，打字慢导致思维也慢，赛时过4题。

c搬寝室 - SMUOJ

思路：贪心和动态规划，但是我wa了十发，maxn没有取到最大（2e15好像只有6万多），其次是有多组数据，最难的部分是动态规划的状态表达式

dp[i][j] = Min(dp[i-2][j-1]+(a[i]-a[i-1])*(a[i]-a[i-1]),dp[i-1][j]);

代码如下：

#include <iostream>
#include <algorithm>
#include<vector>
#include<map>
#include<cstring>
#define int long long
#define PII pair<int,int>
int dp[2010][1010];
int maxn=9999999;
using namespace std;
void solve() {
    int n,k;
    while(cin>>n>>k) {
        int a[2010];
        for (int i = 1; i <= n; i++) cin >> a[i];
        sort(a + 1, a + n + 1);
        memset(dp, maxn, sizeof dp);
        for (int i = 0; i <= n; i++) dp[i][0] = 0;
        for (int i = 2; i <= n; i++) {
            for (int j = 1; j <= i / 2; j++) {
                dp[i][j] = min(dp[i - 2][j - 1] + (a[i] - a[i - 1]) * (a[i] - a[i - 1]), dp[i - 1][j]);
            }
        }
        cout << dp[n][k] << endl;
    }
    return ;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
//    cin>>t;
    while (t--) {
        solve();
    }
}

eHappy Birthday! 2 - SMUOJ

思路：

一个直接的想法就是将所有可能的情况都遍历一边，如果我们使用最暴力的方法，枚举每个元素所在组的情况，时间复杂度将会非常高，因此我们需要另外的解法。考虑到子序列求和后需要对200求余，也就是说我们得到的余数结果的范围在[0,200)之间。题目要求出一对子序列，也就是说总和求余后是一样的。
  这里我们可以根据抽屉原理，知道如果我们计算过201个子序列后，就必定存在两个子序列的总和是同余的。抽屉原理也叫鸽洞原理，简单举个例子就是假设有200个鸽子洞，但是我们有201个鸽子需要回到洞里，那么就必定存在一个洞中有两只鸽子。

  在本题中，对总和求余的所有可能就是例子中的200个鸽子洞，当我们有超过200个子序列的时候，我们就可以得到超过200种可能的求余结果，因此就必定存在两个子序列的求余结果是相同的。同时，对于𝑁个元素，我们可以得到的可能子序列个数为pow(2,N-1)个，当𝑁≥8时，就一定会有结果，而当𝑁<8时，需要判断是否存在结果。
  综上，我们只需要min(𝑛,8)个元素，再利用二进制枚举子序列，最后找到相同余数的子序列（这里的每个子序列保证不会相等）就得到结果，如果不存在就输出𝑁𝑜;

代码：

#include<bits/stdc++.h>
using namespace std;
#define int long long
int n,m,k;
int a[210];
void solve() {
    cin>>n;
    for(int i=0;i<n;i++) cin>>a[i];
    int cnt=min((long long)9,n);
    vector<int>p[210];
//二进制枚举，已经写过很多次了
    for(int i=1;i<(1<<cnt);i++){
        int ct=0;
        vector<int>b;
        for(int j=0;j<cnt;j++){
            if((i>>j)&1) {
                ct=(ct+a[j])%200;
                b.push_back(j+1);
            }
        }
//如果之前已经搜到了余数相同的子序列，直接输出
        if(p[ct].size()!=0){
            cout<<"YES"<<endl;
            cout<<p[ct].size();
            for(int u=0;u<p[ct].size();u++){
                cout<<" "<<p[ct][u];
            }
            cout<<endl;
            cout<<b.size();
            for(int u=0;u<b.size();u++){
                cout<<" "<<b[u];
            }
            return ;
        }
//如果没有搜到，将当前状态的数组放到p中
        else {
            p[ct]=b;
        }
    }
    cout<<"NO"<<endl;
}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int t = 1;
//    cin>>t;
    while (t--) {
        solve();
    }
    return 0;
}

fBowls and Dishes - SMUOJ

思路：用map储存所有的条件，这里可能会有重复条件，再用二进制枚举所有的情况

代码：

#include <iostream>
#include <algorithm>
#include<vector>
#include<map>
#define int long long

#define PII pair<int,int>
using namespace std;
map<PII,int>mp;
vector<PII>b;
void solve() {
    int n,m,k;
    cin>>n>>m;
    b.reserve(200);
    for(int i=0;i<m;i++){
        PII x;
        cin>>x.first>>x.second;
        int h=min(x.first,x.second);
        x.second=max(x.first,x.second);
        x.first=h;
        if(mp.count({x})) {
            int ttt=mp[x];
            mp.erase(x);
            mp.insert({x,1+ttt});
        }
        else mp.insert({x,1});
    }
    cin>>k;
    for(int i=0;i<k;i++) {
        cin>>b[i].first>>b[i].second;
    }
    int sum=0;
    for(int i=0;i<=(1<<k);i++){
        int ans=0;
        int p[100000];
        int tt=0;
        for(int j=0;j<k;j++){
            if(((i>>j)&1)==1){
                p[tt++]=b[j].second;
            }
            else{
                p[tt++]=b[j].first;
            }
        }
        sort(p,p+tt);
        map<PII,int>mpp;
        for(int j=0;j<tt;j++){
            for(int g=j;g<tt;g++){
                if(mp.count({p[j],p[g]})&&mpp.count({p[j],p[g]})==0) {
                    ans += mp[{p[j], p[g]}];
//                    cout << p[j]<<p[g]<<"    " << ans << endl;
                    mpp.insert({{p[j], p[g]}, 2});
                }
            }
        }
//        cout<<ans<<endl;
        sum=max(sum,ans);
    }
    cout<<sum<<endl;

}
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
        int t = 1;
//    cin>>t;
        while (t--) {
            solve();
        }
    }

*gRush Hour 2 - SMUOJ

题意：给定一张无向图，边带两个参数 𝑐𝑖,𝑑𝑖，在 𝑡 时间时经过第 𝑖 条边所需的时间是 𝑐𝑖+⌊𝑑𝑖𝑡+1⌋，求在时间 0 时出发，在每个点可以停留非负整数时间，从点 1 到点 𝑛 所需的最短时间。

思路：（我脑子真的转不动了，求放过）

代码：无

*hCount Descendants - SMUOJ

题意：给你一棵树，q次询问；
每次询问输入两个数，u，d；
要求计算出在树的第d层并且是节点u的子孙节点的节点个数

思路：dfs与二分

通过题目可以容易地看出，要从树的第d层寻找合法答案，那么求节点所在层数可以用dfs/bfs求出
不好解决的地方在于如何快速确定在第d层的节点，有哪些的祖先是u
可以想到的方法是倍增去找，但对于本题来说显然不够高效
有一种更好的方法，就是维护每个节点进出的时间戳（即先序in后序out）
可以容易地想到，对于一对节点u，v，当u为v的祖先节点时，有in[u]<in[v]<out[u]
通过这样的性质，我们可以通过祖先节点u很快的确定u的子孙节点的范围
即我们可以先记录一下每一层的节点的in值，再通过二分来确定范围
这个范围的左边界-右边界即为题目所求的答案

代码：

#include<bits/stdc++.h>
using namespace std;

vector<int> ve[200005];
bool vis[200005];
int in[200005];
int out[200005];
vector<int> ce[200005];
int tim=0;
int ceng;

void dfs(int x,int step)
{
    ceng=max(ceng,step);
    vis[x]=1;
    in[x]=++tim;
    ce[step].push_back(in[x]);
    int Size=ve[x].size();
    for(int i=0;i<Size;i++)
    {
        if(!vis[ve[x][i]])
        {
            dfs(ve[x][i],step+1);
        }
    }
    out[x]=++tim;
}

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=2;i<=n;i++)
    {
        int temp;
        scanf("%d",&temp);
        ve[temp].push_back(i);
        ve[i].push_back(temp);
    }
    dfs(1,1);
    int q;
    scanf("%d",&q);
    while(q--)
    {
        int u,d;
        scanf("%d%d",&u,&d);
        d++;
        int l=lower_bound(ce[d].begin(),ce[d].end(),in[u])-ce[d].begin();
        int r=upper_bound(ce[d].begin(),ce[d].end(),out[u])-ce[d].begin();
        printf("%d\n",r-l);
    }
    return 0;
}