[NOIP2017模拟]星星

最新推荐文章于 2023-06-28 18:08:08 发布

偶尔诈尸的老年人

最新推荐文章于 2023-06-28 18:08:08 发布

阅读量249

点赞数

分类专栏： -------NOIP模拟------- -------图论------- 文章标签： noip 图论

本文链接：https://blog.csdn.net/g19zwk/article/details/78397749

版权

-------NOIP模拟------- 同时被 2 个专栏收录

93 篇文章 0 订阅

订阅专栏

-------图论-------

24 篇文章 0 订阅

订阅专栏

2017.10.30 T3 2019

样例数据
输入

2
4 5
1 2
2 3
3 4
4 1
1 3
4 6
1 2
2 3
3 4
4 1
1 3
2 4

输出

1
6

分析：在考场上，我想到一种感觉是正解的做法：枚举每一个度>=3的点，给它所有的边连的点打上标记且把其中度>=3的入栈，然后枚举每一个栈中点所有边连的点，如果是有标记的就cnt++，枚举完一个的就排列组合更新一下ans。这样，在稠密图中是O( $N^3$ )，在稀疏图中是O( $NM$ )，可以说是很优了，可以过70%呢，正好判断数组也可以开到那么大，就这么交了。
结果，正解基本上就是我的方法，是我算错了复杂度，我的算法是O( $M\sqrt M$ )，只是正解运用了巧妙的去重方法，避免了数组开炸的情况：每个点只算度和比自己小的点构成了多少鲤鱼图，这样也保证了不会重复运算。
复杂度证明如下：
考虑把点按度是否大于 $\sqrt m$ 分为重轻点，那所有边可分为三种：
1.轻点连轻点的边：如果整个图有O(m)条，由于按照 $\sqrt m$ 分为重轻点，所以每个轻点的边集最多只有O( $\sqrt m$ )，总复杂度为O( $m\sqrt m$ )。
2.重点连轻点的边：如果全图有O(m)条，这种算法就只会枚举轻点的边集，只有O( $\sqrt m$ )，总复杂度也为O( $m\sqrt m$ )。
3.重点连重点的边：对于一个重点①最多涉及O(m)条边，因为重点②的度至少都是O( $\sqrt m$ )条，所以总共最多也只有O(2 $\sqrt m$ )个重点，这两个条件又无法同时达到，所以总复杂度也为O( $m\sqrt m$ )。
所以算法总复杂度为O( $m\sqrt m$ )。

代码
70%用数组判重的悲剧

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#include<queue>
#include<set>
using namespace std;

int getint()
{
    int sum=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch)&&ch!='-';ch=getchar());
    if(ch=='-')
    {
        f=-1;
        ch=getchar();
    }
    for(;isdigit(ch);ch=getchar())
        sum=(sum<<3)+(sum<<1)+ch-48;
    return sum*f;
}

const int maxn=100010;
const int maxm=200010;
int T,n,m,du[maxn];
long long ans;
int tot,first[maxn],nxt[maxm*2],to[maxm*2];
int bian[2010][2010],zhan[maxn];//就是bian这个数组不能再开大了
bool visit[maxn];

inline void addedge(int x,int y)
{
    tot++;
    nxt[tot]=first[x];
    first[x]=tot;
    to[tot]=y;
    tot++;
    nxt[tot]=first[y];
    first[y]=tot;
    to[tot]=x;
}

inline void sol(int u)
{
    int top=0;
    for(register int p=first[u];p;p=nxt[p])
    {
        int v=to[p];
        if(du[v]>=3&&bian[u][v]==false)//对面的点度也大于3且没有和它配过对
        {
            zhan[++top]=v;//放入栈中
            bian[u][v]=true;
            bian[v][u]=true;
        }
        visit[v]=true;//给每个连接的点都打上标记
    }

    long long cnt;
    for(int i=1;i<=top;++i)//枚举栈中点
    {
        cnt=0;
        for(register int p=first[zhan[i]];p;p=nxt[p])//枚举每一条边
        {
            int v=to[p];
            if(visit[v])//有标记的说明是形成了三角形的
                cnt++;//计数
        }

        ans+=cnt*(cnt-1)/2;//排列组合这些三角形更新ans
    }

    for(register int p=first[u];p;p=nxt[p])//把visit清零
    {
        int v=to[p];
        visit[v]=false;
    }
}

int main()
{
    freopen("star.in","r",stdin);
    freopen("star.out","w",stdout);

    int x,y;srand(time(0));
    T=getint();
    while(T--)
    {
        for(register int i=1;i<=n;++i)//清零操作
            first[i]=0;
        for(register int i=1;i<=n;++i)
            for(int j=1;j<=n;++j)
                bian[i][j]=0;
        for(register int i=1;i<=n;++i)
            du[i]=0;
        tot=0,ans=0;

        int x,y;
        n=getint(),m=getint();
        for(register int i=1;i<=m;++i)
        {
            x=getint(),y=getint();
            du[x]++,du[y]++;
            addedge(x,y);
        }

        if(n<=2000)
        {
            for(register int i=1;i<=n;++i)
                if(du[i]>=3)//枚举每一个度>=3的点
                    sol(i);
        }
        else
        {
            if(m==n*(n-1)/2)
                ans=n*(n-1)*(n-2)*(n-3)/4;
            else
                ans=rand();//大于2000就随缘了hhhh
        }
        cout<<ans<<'\n';
    }
    return 0;
}

100%：永远只和度比自己小的点配对（比我写的短orz）

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<cctype>
#include<iomanip>
#include<queue>
#include<set>
using namespace std;

int getint()
{
    int sum=0,f=1;
    char ch;
    for(ch=getchar();!isdigit(ch)&&ch!='-';ch=getchar());
    if(ch=='-')
    {
        f=-1;
        ch=getchar();
    }
    for(;isdigit(ch);ch=getchar())
        sum=(sum<<3)+(sum<<1)+ch-48;
    return sum*f;
}

const int maxn=100010;
const int maxm=200010;
int T,n,m,du[maxn],visit[maxn];
long long ans;
int tot,first[maxn],nxt[maxm*2],to[maxm*2];

inline void addedge(int x,int y)
{
    tot++;
    nxt[tot]=first[x];
    first[x]=tot;
    to[tot]=y;
    tot++;
    nxt[tot]=first[y];
    first[y]=tot;
    to[tot]=x;
}

int main()
{
    freopen("star.in","r",stdin);
    freopen("star.out","w",stdout);

    int x,y;
    T=getint();
    while(T--)
    {
        memset(first,0,sizeof(first));//清零操作
        memset(visit,0,sizeof(visit));
        memset(du,0,sizeof(du));
        tot=0,ans=0;

        int x,y;
        n=getint(),m=getint();
        for(register int i=1;i<=m;++i)
        {
            x=getint(),y=getint();
            du[x]++,du[y]++;
            addedge(x,y);
        }

        for(register int i=1;i<=n;++i)//枚举每一个点（其实可以优化成像我一样只有度>=3的才进行下面的操作）
        {
            for(register int e=first[i];e;e=nxt[e]) visit[to[e]]=i;//打标记，这种打成自己编号的方法很妙，不需要清零
            for(register int e=first[i];e;e=nxt[e])
            {
                int v=to[e];
                if(du[v]<=du[i])//枚举每一个点，找度小于等于自己的
                {
                    if(du[i]==du[v]&&v<=i) continue;//如果度等于自己而且编号比自己小，说明那个点在自己之前就已经和自己配过对了，不管了
                    int cnt=0;
                    for(register int p=first[v];p;p=nxt[p])//和我相同的操作
                        if(visit[to[p]]==i) cnt++;
                    ans+=(long long)cnt*(cnt-1)/2;
                }
            }
        }
        cout<<ans<<'\n';
    }
    return 0;
}