1697E - Coloring

E. Coloring

链接:problem

题意

给定平面上的 $n$ 个点的坐标$(x_i,y_i)$, 其中没有两点有相同的坐标 。定义点$i,j$ 间的距离为 $d(i,j)=|x_i-x_j|+|y_i-y_j|$.现用 $n$ 种颜色对这些点进行染色，求满足以下条件的方案数：

• 每种相同颜色的点两两间距离相等
• 每个点到具有不同颜色的点的距离总大于与其颜色相同的其他点（若存在）的距离。

$2\le n\le 100$

$0\le x_i,y_i\le 10^8$

分析

由题意可知：

1. 如果两个点$a,b$为同色点，则$a$的最短距离点为$b$点，同理$b$的最短距离点为$a$点，$a,b$互为最短距离点。
2. 一堆可同色点要么都同色，要么都都不相同。

证明：

1.若$a,b$为同色点，则对于任意其他点$c,d(a,b)<d(a,c),d(a,b)<d(b,c)$,不可能存在$c$点使得$a,b$的最短距离点为$c$。

2.假设$a$的最短距离点有$b,c$；$b$的最短距离点为$d$;$a,b,c,d$为可能同色的点集，$a,b$不互为最短距离点，因此不可能为同色点；假如$a,c$互为最短距离点，由于$d(a,c)=d(a,b),d(a,c)\le d(c,b)$,故$a,c$也不可能是同色点，由此可推出一个可能同色的点集中的每一个点，要么颜色相同，要么互不相同

做法：

首先不难想到把每个点向其最近点连接一条有向边，那么当一堆点可同色时，当且仅当它们构成了完全图。反之，即全部为孤立点。这时候不难想到正解：对于每个点，找出它能到的所有点，判断这些点两两之间是否都有边。时间复杂度$O(n^3)$.

找到一堆同色点集后，设 $a_i$为第 $i$ 个同色点集的大小。

设$dp[i][j]$表示前i个点集，用j种颜色染色,对于每一个点集，有两种方法进行染色，第一种就是点集染一个颜色,第二种就是点集中每一个点染一种颜色
因此可以写出状态转移方程：

若点集个数为1：$dp[i+1][j+1]+=dp[i][j];$

若点集个数为a: $dp[i+1][j+a]+=dp[i][j],dp[i+1][j+1]+=dp[i][j]$;

最后答案为： $\sum d{p}_i\times A_n^i$

代码

    #include<bits/stdc++.h>
    using namespace std;
    const int N = 143;
    const int K = 5;
    const int MOD = 998244353;
    int fact[N];       //阶乘
    int rfact[N];      //逆元
    int n;
    vector<int> g[N];  //g[i][]表示i的最短距离点集合
    int x[N];
    int y[N];
    int dist[N][N];   //两个点之间的曼哈顿距离
    int color[N];
    int dp[N][N];     
    int cc = 0;      //当前是第几种颜色
    set<int> pts;      //可能相同颜色的点集
    vector<int> compsize;   //点集中点的数量
    int add(int x, int y)    //求(x+y)%MOD
    {
        x += y;
        while(x >= MOD) x -= MOD;
        while(x < 0) x += MOD;
        return x;   
    }
    int mul(int x, int y)   //求(x*y)%MOD
    {
        return (x * 1ll * y) % MOD;
    }
    //快速幂
    int binpow(int x, int y)
    {
        int z = 1;
        while(y > 0)
        {
            if(y % 2 == 1) z = mul(z, x);
            x = mul(x, x);
            y /= 2;
        }
        return z;
    }  
    //求排列数
    int A(int n, int k)
    {
        return mul(fact[n], rfact[n - k]);
    }  
    //DFS求可能相同的颜色的点集
    void dfs1(int i)
    {
        if(pts.count(i) == 1) return;
        pts.insert(i);
        for(auto v : g[i])
        {
            dfs1(v);
        }
    } 
    //DFS给除了孤立点外的点集染色
    void dfs2(int i, int c)
    {
        if(color[i] == c) return;
        color[i] = c;
        for(auto v : g[i])
            dfs2(v, c);
    }  
    int main()
    {
        fact[0] = 1;
        for(int i = 1; i < N; i++)
            fact[i] = mul(i, fact[i - 1]);
        for(int i = 0; i < N; i++)   //快速幂求逆元
            rfact[i] = binpow(fact[i], MOD - 2);
        cin>>n;
        for(int i = 0; i < n; i++)
            cin>>x[i]>>y[i];    
        for(int i = 0 ; i < n; i++)
        {
            dist[i][i] = int(1e9);
            for(int j = 0; j < n; j++)
                if(i != j)
                    dist[i][j] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
        }
        for(int i = 0; i < n; i++)
        {
            int d = *min_element(dist[i], dist[i] + n);
            for(int j = 0; j < n; j++)
                if(dist[i][j] == d) g[i].push_back(j);    
        }
        for(int i = 0; i < n; i++)
        {
            if(color[i] != 0) continue;
            cc++;
            pts.clear();
            dfs1(i);
            int d = *min_element(dist[i], dist[i] + n);                      
            set<int> pts2 = pts;
            bool bad = false;
            for(auto x : pts)
                for(auto y : pts2)
                    if(x != y && dist[x][y] != d)
                        bad = true;
            if(bad)           //如果存在两个点不互为最短距离点，则点集中每一个点为孤立点
            {
                color[i] = cc;
                compsize.push_back(1);
            }
            else   //反之，染色法染色
            {
                dfs2(i, cc);
                compsize.push_back(pts.size());
            }
        }            
        dp[0][0] = 1;
        int m = compsize.size();
        for(int i = 0; i < m; i++)
            for(int j = 0; j < n; j++)
            {
                int a=compsize[i];
                if(dp[i][j] == 0) continue;
                dp[i + 1][j + 1] = add(dp[i + 1][j + 1], dp[i][j]);//点集每一个点染一样的颜色
                if(compsize[i] != 1)   //染不一样的颜色
                {
                    dp[i + 1][j + a] = add(dp[i + 1][j + a], dp[i][j]);
                }
            }
        int ans = 0;
        for(int i = 1; i <= n; i++)
            ans = add(ans, mul(dp[m][i], A(n, i)));
        cout << ans << endl;
    }