离线赛20171008总结

考试时的状态

　　这次考试总的来说考得很糟，前面三个小时基本都在梦游，不知道自己在该干什么。看了半天题目，连最基本的排序都没想起来，用计数算了半天，却被重复运算搞懵了，这些特殊情况都不该出现的。基本上分数都是最后半小时拿来的，自然也不会考得很高了。

题解

第一题：

　　这道题关键考察的就是排列组合，这里有一个很重要的结论，那就是c［i］［j］=c［i-1］［j］＋ｃ［ｉ－１］［ｊ－１］。这个结论的推导也是比较容易的，当产生一个新的元素x时，要么取用x，那么x接在任何组合中都可以，要么不取用x，那么就变成了在前i-1个元素中取用j个元素，这个递推公式非常重要，因为在算法的取模运算中，是不可以先模后除的，因此用加法递推，首先不会错，其次可以预处理，运算效率高。其实还有一种逆元方法。一个数x的逆元y的定义就是(x*y)%P=1。那么一个数除上x就等同于乘上y再取模，这个算法正确性也是显然的。那么y该怎么求呢？由费马小定理可知，如果P为质数，那么(x^(p-1）)%P=1。所以y=x^(P-2)。而这个乘方计算，可以用快速幂来完成。因此接下来就可以把每一个阶乘都预处理出来，在计算c(m,n)=n!/(m!)(n-m)!时只要乘上逆元就可以了。

代码：

#include<iostream>
#include<cstdio>
#include<algorithm>
#define M 100086
#define FOR(i,a,b) for(register int i=(a),i##_end_=(b);i<=i##_end_;++i)
#define DOR(i,a,b) for(register int i=(a),i##_end_=(b);i>=i##_end_;--i)
using namespace std;
const int P=1e9+7;
long long c[60][M];
int A[M];
long long ans=0;
int n,k;
int main(){
    cin>>n>>k;
    FOR(i,1,n)scanf("%d",&A[i]);
    sort(A+1,A+n+1);
    FOR(i,0,n)c[0][i]=1;//c[j][i]=c[j][i-1]+c[j-1][i-1];
    FOR(i,1,n)FOR(j,1,k)c[j][i]=(c[j][i-1]+c[j-1][i-1])%P;
    FOR(i,k,n)ans=(ans+1LL*c[k-1][i-1]*A[i])%P;
    cout<<ans<<endl;
    return 0;
}

第二题

　　这道题玄学，考察的是一个状态压缩DP，每个数字的状态可以用一个二进制数来表示，0表示无数字，1表示有数字。由于每一个状态只与上一层有关系，因此就可以dp了，转移还是比较简单的，就是预处理麻烦了些。

70分代码：

#include<iostream>
#include<algorithm>
#define M 108
#define FOR(i,a,b) for(register int i=(a),i##_end_=(b);i<=i##_end_;++i)
#define DOR(i,a,b) for(register int i=(a),i##_end_=(b);i>=i##_end_;--i)
using namespace std;
const int P=1e9+7;
long long dp[M][1<<13];
long long A[M];
long long ans=0;
int bin[M][15];
int top[M];
int n;
void create(){
    FOR(i,0,n){
        long long x=A[i];
        while(x){
            bin[i][top[i]++]=x%10;
            x/=10;
        }
    }
}
long long change(int i,int flag){
    long long res=0;
    DOR(j,top[i]-1,0){
        if(flag&(1<<j)){
            res=res*10+bin[i][j];
        }
    }
    return res;
}
int main(){
    cin>>A[0]>>n;
    FOR(i,1,n)A[i]=A[i-1]+1;
    create();
    FOR(j,1,(1<<top[1])-1)dp[0][j]=1;
    FOR(i,1,n){
        FOR(j,1,(1<<top[i])-1){
            long long x=change(i,j);
            FOR(k,1,(1<<top[i-1])-1){
                long long y=change(i-1,k);
                if(x>=y)dp[i][j]=(dp[i][j]+dp[i-1][k])%P;
            }
        }
    }
    FOR(j,1,(1<<top[n])-1)ans=(ans+dp[n][j])%P;
    cout<<ans<<endl;
    return 0;
}

第三题

　　这道题，是一道图论题，由于数据比较小，弗洛伊德算法可以拿很多分，我一开始想到了枚举三维，剩下一维进行贪心，但这样的复杂度还是高了些，其实另外一条边也是可以贪心的，只要预处理出每个点作为起点的边权最大值与作为终点的边权最大值，然后就可以贪心了，其实只有中间两个点是有关系的，其他两个点都是相互独立的，因此就可以贪心了。

#include<iostream>
#include<queue>
#include<vector>
#define M 1050
#define FOR(i,a,b) for(register int i=(a),i##_end_=(b);i<=i##_end_;++i)
#define DOR(i,a,b) for(register int i=(a),i##_end_=(b);i>=i##_end_;--i)
using namespace std;
const int INFINITY=1e9;
int d[M][M];
int n,m;
struct Node {
    int to,co;
};
vector<int>edge[M];
struct node {
    int to,co[2],fr;
    int cnt[2];
} Mx[M];
void bfs(int s) {
    d[s][s]=0;
    queue<Node>que;
    que.push((Node) {s,0});
    while(!que.empty()) {
        Node E=que.front();
        que.pop();
        FOR(i,0,edge[E.to].size()-1) {
            int y=edge[E.to][i];
            Node e= {y,E.co+1};
            if(e.co<d[s][y]) {
                d[s][y]=e.co;
                que.push(e);
            }
        }
    }
}
int main() {
    cin>>n>>m;
    FOR(i,1,m) {
        int a,b;
        scanf("%d%d",&a,&b);
        edge[a].push_back(b);
    }
    FOR(i,1,n)FOR(j,1,n)d[i][j]=INFINITY;
    FOR(i,1,n)bfs(i);
    FOR(i,1,n)FOR(j,1,n) {
        if(d[i][j]==INFINITY||i==j)continue;
        if(d[i][j]>Mx[i].co[0])
        Mx[i].co[0]=d[i][j],Mx[i].to=j,Mx[i].cnt[0]=1;
        else Mx[i].cnt[0]+=(d[i][j]==Mx[i].co[0]);
        if(d[i][j]>Mx[j].co[1])
        Mx[j].co[1]=d[i][j],Mx[j].fr=i,Mx[j].cnt[1]=1;
        else Mx[j].cnt[1]+=(d[i][j]==Mx[j].co[1]);
    }
    int ans=0;
    FOR(j,1,n)FOR(k,1,n) {
        if(d[j][k]==INFINITY||
        !Mx[j].cnt[1]||!Mx[k].cnt[0]||j==k)continue;
        if(Mx[j].to==Mx[k].fr&&Mx[j].cnt[0]==1&&Mx[k].cnt[1]==1)continue;
        if(Mx[j].co[1]+d[j][k]+Mx[k].co[0]>ans)
            ans=Mx[j].co[1]+d[j][k]+Mx[k].co[0];
    }
    cout<<ans<<endl;
    return 0;
}

小结

第一题：

　　关键还是思路没找对，一开始一直在想怎么用计数优化，导致浪费了大量时间，接下来的阶乘展开也是浪费了较多时间，因为组合要调用的次数比较多，因此不应该用阶乘展开，而是应该用递推来写，阶乘展开适合用于写系数较大，调用较少的题目（比如双重回文数）。其次，这道题最基本的排序我想了好久都没有get到，其实这道题答案跟元素的位置一点关系也没有，考试的时候一定要考虑到这一点，否则会浪费许多时间。接下来的考试中一定要注意这些点，不能再犯了，特别是不能梦游。

第二题：

这道题关键是没有时间，其次，要是有时间的话，估计也不会那么轻易想到状压动归，对于一些特殊数字一定要敏感，比方说刻画状态时只有两种状态，取和不取，状态数据在10左右，很有可能就是状态压缩动态规划。上次的炮兵那道题也是这个思路。

第三题：

这道题我一上来就打了个弗洛伊德，水分达到了要多水就多水的境界，这样的话正确性就很高了，拿来对拍肯定不会出问题，正像小C说的，对拍的代码应该要多暴力就多暴力，要保证自己是对的，不过这次没来得及对拍，还是策略上出了问题啊，第一题花的时间太多了。

总结

这次考得很烂，有些问题要注意，策略上要注重，不过写来还是有收获的，这些经验都要总结了才有用。

written by ShimaKZ