2021牛客国庆集训派对day1 A,D,E

A Monotonic Matrix
链接：https://ac.nowcoder.com/acm/contest/20322/A
题意：
给定一个矩阵的长和宽，求满足下列要求的矩阵数量
Ai, j ∈ {0, 1, 2} for all 1 ≤ i ≤ n, 1 ≤ j ≤ m.
Ai, j ≤ Ai + 1, j for all 1 ≤ i < n, 1 ≤ j ≤ m.
Ai, j ≤ Ai, j + 1 for all 1 ≤ i ≤ n, 1 ≤ j < m.

思路：
构造几个合法的矩阵就可知矩阵被分成了3个部分，每个部分被0,1,2其中一个填充

考虑01分界线和12分界线,可知2个分界线的不同形状，就对应了一个合法的矩阵

那么问题就变成了求有多少种情况2个分界线是合法的

可知分界线是从(n ,0) 到 (0,m)的一条线
如果只有一条线：
从(n,0)到(0,m)的总步数需要n + m
那么就需要在n + m 中挑选出来m步往上走

所以方案数为 C(m,n + m)

现在有2条线：
首先2条线不能出现交叉的情况
因为要运用到LGV定理所以，也不能有重合的地方

那么可以把其一条线进行平移
起点变为(n - 1,- 1),(- 1,m - 1)
那么问题就变成了
求 从点 (n,0)到(0,m)的路径和从(n - 1,- 1)到(- 1,m - 1)的路径，他们不相交的方案数
这样就解决了重合

然后运用LGV

这里起点的集合是
a = {(n - 1,- 1),(n ,0)}
终点的集合是
b = {(- 1,m - 1),(0,m)}

设
a1 = (n - 1,- 1),a2 = (n ,0)
b1 = (- 1,m - 1) ,b2 = (0,m)

e(a1,b1) = C(m,n + m)
e(a1,b2) = C(n - 1,n + m)
e(a2,b1) = C(m - 1,n + m)
e(a2,b2) = C(m,m + n)

所以答案就是
e(a1,b1) * e(a2,b2) - e(a2,b1) * e(a1,b2)

#include <iostream>

using namespace std;

const int N = 2e3 + 10,mod = 1e9 + 7;
int f[N][N];

void init()
{
    f[0][0] = 1;
    for(int i = 1;i < N;i ++)
        for(int j = 0;j <= i;j ++)
            if(j == 0) f[i][j] = 1;
            else f[i][j] = (f[i - 1][j] * 1ll + f[i - 1][j - 1]) % mod;
    return ;
}

int main()
{
    init();
    
    int n,m;
    while(cin >> n >> m)
    {
        int res = f[n + m][m] * 1ll * f[n + m][m] % mod - f[n + m][m - 1] * 1ll * f[n + m][n - 1] % mod;
        cout << (res + mod) % mod << endl;
    }
    
    return 0;
}

D Two Graphs
链接：https://ac.nowcoder.com/acm/contest/20322/D

题意：
给定一个小图，一个大图，找出大图中有多少子图是和小图同构的

思路：

同构：
1,2个图的边数和点数相等
2.一个图中的点与另一个图的点进行某种映射后，他们的结构一样

那么问题也就是在大图中找有多少个小图

题中的点数非常小，所以可以枚举点之间的映射，当映射枚举好后，就要看这种映射能不能让小图和大图的子图同构，所以现在的问题就是如何判断同构

既然同构，那么邻接矩阵肯定是一样的，所以只要判断，2个图的邻接矩阵是否一样，一样就满足

又因为可能某些映射，对应的子图是一样的，所以还要去重，这里可以给大图的每个边都编一个号，放在邻接矩阵中，然后再用二进制来表示合法子图，所对应的边，然后用map去重

#include <iostream>
#include <cstring>
#include <map>
#include <algorithm>

using namespace std;

const int N = 10;
map<long long ,int> mp;
int u1[N][N],u2[N][N];
int n,m1,m2;
int f[N];

int main()
{
    while(cin >> n >> m1 >> m2)
    {
        memset(u1,0,sizeof u1);
        memset(u2,0,sizeof u2);
        mp.clear();
        
        for(int i = 1;i <= m1;i ++)
        {
            int a,b;
            cin >> a >> b;
            u1[a][b] = u1[b][a] = 1;
        }
        
        for(int i = 1;i <= m2;i ++)
        {
            int a,b;
            cin >> a >> b;
            u2[a][b] = u2[b][a] = i;
        }
        
        for(int i = 1;i <= n;i ++)
             f[i] = i;
        int res = 0;
        do 
        {
            int flag = 1;
            long long to = 0;
            for(int i = 1;i <= n;i ++)
                for(int j = 1;j <= n;j ++)
                    if(u1[i][j])
                    {
                        if(u2[f[i]][f[j]] == 0) flag = 0;
                        to |= 1ll << u2[f[i]][f[j]];
                    }
            if(flag && mp[to] == 0) 
            {
                res ++;
                mp[to] = 1;
            }
            
        }while(next_permutation(f + 1,f + n + 1));
        cout << res << endl;
    }
    return 0;
}

E Removal

题意：
给定一个序列，问精确删除k个数字后不同的序列数量

思路：
看到n和k的范围可以想到使用dp计数
f[i,j] 表示前i个数删除j个数的方案数

于是用过第j个数删和不删可以分成
f[i,j] = f[i - 1,j - 1] + f[i - 1,j]

不过发现，数并不是唯一的，如果存在相同数的话，有可能有重复的

比如
1 2 3 4 5 6 3

f[i - 1,j - 1]中有 1 2 3(删除[4,7])
f[i - 1,j] 中有1 2 3(删除[3 , 6])

所以需要减去其中一种

现在减去 f[i - 1,j]中重复的
假设第j个数是x，下标为idx，它上一次出现的位置是idx2
那么[idx2 , idx - 1]都被删除后，才会出现重复
还有j - i + idx2个要删除
所以在上面转移方程的前提下还要减去
f[idx2 - 1,j - i + idx2]

#include <iostream>

using namespace std;

const int N = 1e5 + 10,mod = 1e9 + 7;
int f[N][12];
int id[20];
int a[N];

int main()
{
    int n,m,k;
    while(cin >> n >> m >> k)
    {
        for(int i = 0;i <= n;i ++)
           for(int j = 0;j <= m;j ++) f[i][j] = 0;
        for(int i = 1;i <= k;i ++) id[i] = 0;
        for(int i = 0;i <= n;i ++) f[i][0] = 1;
        
        for(int i = 1;i <= n;i ++) cin >> a[i];
        
        for(int i = 1;i <= n;i ++)
        {
            for(int j = 1;j <= m;j ++)
            {
                f[i][j] = (f[i - 1][j - 1] * 1ll + f[i - 1][j]) % mod;
                if(id[a[i]] && j - i + id[a[i]] >= 0)    
                    f[i][j] =(f[i][j] * 1ll - f[id[a[i]] - 1][j - i + id[a[i]]]) % mod;
                     
            }
            id[a[i]] = i;
        }
        
        cout << (f[n][m] + mod) % mod << endl;
        
    }
    return 0;
}