[ARC099E] Independence

算法

想到了建立补图之后二分图的处理, 有一点水平但不多

显然的, 建立补图之后, 一个团之间不存在边, 只有团之间可能出现边, 那么如果出现了奇环, 显然无解

但是这个二分图比较奇妙啊, 有些二分图是孤立在外的, 但是我们发现, 补图中孤立在外, 那么在原图中, 它们就一定可以并成一个完全子图, 这个画画图可以做出来, 那么每个二分子图的两个点集都可以随意加到哪个最终点集之一

那么现在问题转化为, 如何求这些点集的最优分配, 这个时候 \(\rm{TJ}\) 的作用就出来了

显然的, 我们将点集任意组合都行, 那直接开个数组标记一下即可

完成

代码

建补图, 二分图染色判断无解

计算两个点集的可能数量, 枚举求最值

后补, 先去看 \(\rm{T4}\)

#include <bits/stdc++.h>
#define int long long
const int MAXN = 2e3 + 20;
const int MAXM = 2e6 + 20;
int n, m;

class Sol_Class
{
private:
    struct node {
        int to, next;
    } Edge[MAXM << 1];
    int head[MAXN], Edge_Cnt = 0;
    void addedge(int u, int v) {
        Edge[Edge_Cnt].to = v;
        Edge[Edge_Cnt].next = head[u], head[u] = Edge_Cnt;
        Edge_Cnt++;
    }

    /*建补图*/
    void makegraph() {
        scanf("%lld %lld", &n, &m);
        memset(head, -1, sizeof(head));
        for (int i = 1; i <= n; i++) {
            std::string Mat; std::cin >> Mat; Mat = ' ' + Mat;
            for (int j = 1; j <= n; j++) {
                if (Mat[j] == '0' && i != j) addedge(i, j);
            }
        }
    }

    int Color[MAXN]; // 0, 1 两种颜色
    bool dfs1(int Now, int Col) {
        Color[Now] = Col;
        Size[gracnt][Col]++;
        for (int i = head[Now]; ~i; i = Edge[i].next) {
            int NowTo = Edge[i].to, NextCol = !Col;

            /*判定无解*/
            if (~Color[NowTo] ? Color[NowTo] != NextCol : !dfs1(NowTo, NextCol))
                return false;
        }
        return true;
    }
    int Size[MAXN][2];
    int gracnt = 0;
    /*二分图染色*/
    void stain()
    {
        memset(Color, -1, sizeof Color);
        for (int i = 1; i <= n; i++) {
            Size[gracnt + 1][0] = Size[gracnt + 1][1] = 0, gracnt++;
            if (~Color[i]) continue;

            if (!dfs1(i, 0)) {
                printf("-1");
                exit(0);
            }
        }
    }

    bool CanChose[MAXN];

    int calc(int x) {
        return x * (x - 1) / 2 + (n - x) * (n - x - 1) / 2;
    }

public:
    void solve()
    {
        makegraph();
        stain();

        memset(CanChose, false, sizeof(CanChose));
        CanChose[0] = true;
        for (int i = 1; i <= gracnt; i++)
            for (int j = n; j >= 0; j--) {
                bool flag = false;
                if (j >= Size[i][0]) flag |= CanChose[j - Size[i][0]];
                if (j >= Size[i][1]) flag |= CanChose[j - Size[i][1]];
                CanChose[j] = flag;
            }

        int Ans = 0x3f3f3f3f;
        for (int i = 0; i <= n; i++) {
            if (CanChose[i]) {
                Ans = std::min(Ans, calc(i));
            }
        }

        printf("%lld", Ans);
    }
} Sol;

signed main()
{
    Sol.solve();
    return 0;
}

总结

注意思路的转化, 不要因为小问题放弃这个做法

注意背包写法