QOJ.ac

QOJ

ID题目提交者结果用时内存语言文件大小提交时间测评时间
#713688#5307. Subgraph IsomorphismGodwangWA 42ms7668kbC++237.1kb2024-11-05 20:17:492024-11-05 20:17:50

Judging History

你现在查看的是最新测评结果

  • [2024-11-05 20:17:50]
  • 评测
  • 测评结果:WA
  • 用时:42ms
  • 内存:7668kb
  • [2024-11-05 20:17:49]
  • 提交

answer

#include <iostream>
using namespace std;
#include <set>
#include <algorithm>
#include <cmath>
#include <map>
#include <cstdio>
#include <string>
#include <cstring>
#include <string.h>
#include <stdlib.h>
#include <iomanip>
#include <fstream>
#include <stdio.h>
#include <stack>
#include <queue>
#include <ctype.h>
#include <vector>
#include <random>
#include<list> 
#define ll long long
#define ull unsigned long long
#define pb push_back
#define rep(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = n; i >= a; i--)
#define pii pair<int, int>
#define pli pair<ll, int>
#define pil pair<int, ll>
#define pll pair<ll, ll>
#define lowbit(x) ((x)&(-x))
ll extend_gcd(ll a, ll b, ll &x, ll &y)
{
    if (b == 0)
    {
        x = 1;
        y = 0;
        return a;
    }
    ll d = extend_gcd(b, a % b, y, x);
    y -= a / b * x;
    return d;
}
ll fastpow(ll a, ll n, ll mod)
{
    ll ans = 1;
    a %= mod;
    while (n)
    {
        if (n & 1)
            ans = (ans * a) % mod; //% mod
        a = (a * a) % mod;         //% mod
        n >>= 1;
    }
    return ans;
}

inline void write(__int128 x)
{
    if (x > 9)
    {
        write(x / 10);
    }
    putchar(x % 10 + '0');
}
__int128 sqrt(__int128 m)
{
    __int128 leftt = 0, rightt = ((__int128)1) << 51, ret = -1, mid;
    while (leftt < rightt)
    {
        mid = (leftt + rightt) / 2;
        if (mid * mid > m)
        {
            rightt = mid;
        }    
        else
        {
            leftt = mid + 1;
            ret = mid;
        }
    }
    return ret;
}

const double eps = 1e-6;
int sgn(double x)
{
    if(fabs(x)<eps)
    {
        return 0;
    }
    else return x<0?-1:1;
}

struct Point
{
    double x,y;
    Point()
    {

    }
    Point(double x,double y):x(x),y(y)
    {

    }
    Point operator + (Point B)
    {
        return Point(x+B.x,y+B.y);
    }
    Point operator - (Point B)
    {
        return Point(x-B.x,y-B.y);
    }
    bool operator == (Point B)
    {
        return sgn(x-B.x)==0&&sgn(y-B.y)==0;
    }
    bool operator < (Point B)
    {
        return sgn(x-B.x)<0||(sgn(x-B.x)==0&&sgn(y-B.y)<0);
    }
};
typedef Point Vector;
double Cross(Vector A,Vector B)//叉积
{
    return A.x*B.y-A.y*B.x;
}
double Distance(Point A,Point B)
{
    return hypot(A.x-B.x,A.y-B.y);
}
int Convex_hull(Point *p,int n,Point *ch)
{
    n=unique(p,p+n)-p;
    sort(p,p+n);
    int v=0;

    for(int i=0;i<n;i++)
    {
        while (v>1&&sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-1]))<=0)
        {
            v--;
        }
        ch[v++]=p[i];
    }

    int j=v;

    for(int i=n-2;i>=0;i--)
    {
        while (v>j&&sgn(Cross(ch[v-1]-ch[v-2],p[i]-ch[v-1]))<=0)
        {
            v--;
        }
        ch[v++]=p[i];
    }
    if(n>1)
    {
        v--;
    }
    return v;
}

int kmp(string s, string p)
{
    int ans = 0, lastt = -1;
    int lenp = p.size();
    vector<int > Next(lenp+3,0);
    rep(i, 1, lenp - 1)
    {
        int j = Next[i];
        while (j && p[j] != p[i])
        {
            j = Next[j];
        }
        if (p[j] == p[i])
        {
            Next[i + 1] = j + 1;
        }
        else
        {
            Next[i + 1] = 0;
        }
    }
    int lens = s.size();
    int j = 0;
    rep(i, 0, lens - 1)
    {
        while (j && s[i] != p[j])
        {
            j = Next[j];
        }
        if (s[i] == p[j])
        {
            j++;
        }
        if (j == lenp)
        {
            ans++;
        }
    }
    return ans;
}

int dir[4][2] =
    {
        {-1, 0}, {0, 1}, {1, 0}, {0, -1}}; // 左右上下
// int dir[8][2]={
//         {-1, 0}, {0, 1}, {1, 0}, {0, -1},{-1,-1},{-1,1},{1,-1},{1,1}
// };
        
#define endl '\n'//交互题请删除本行
const ll inf = 1000000000000000000ll;
const ll mod1 = 998244353ll, P1 = 131, mod2 = 1e9 + 7ll, P2 = 13331;
ll inverse(ll x)
{
    return fastpow(x,mod1-2,mod1);
}

const int N = 1e6 + 10, M = 1e6 + 10;

///////////////////////////////////

int tt;

int n,m;


ll dp[N];

vector<int > v[N];
bool vis[N];
int d[N];
vector<int > huan;

///////////////////////////////////

void yu(int u)
{
    huan.pb(u);
    vis[u]=1;
    for(auto i:v[u])
    {
        if(vis[i]==0)
        {
            yu(i);
        }
    }
}

void dfs(int u)
{
    vis[u]=1;
    for(auto i:v[u])
    {
        if(vis[i]==0)
        {
            dfs(i);
            ll add=dp[i]*P1%mod1;
            dp[u]+=add;
            dp[u]%=mod1;
        }
    }
}

bool judge()
{
    ll num=dp[huan[0]];
    bool ret=1;
    for(auto i:huan)
    {
        if(dp[i]!=num)
        {
            ret=0;
            break;
        }
        
    }
    if(ret)
    {
        return 1;
    }

    if(huan.size()%2==0)
    {
        ll num0=dp[huan[0]],num1=dp[huan[1]];
        int id=1;
        for(auto i:huan)
        {
            id^=0;
            if(id==0&&dp[i]!=num0||id==1&&dp[i]!=num1)
            {
                return 0;
            }
        }

        return 1;
    }
    return 0;

}

///////////////////////////////////

void init()
{
    rep(i,1,n)
    {
        v[i].clear();
    }
    rep(i,1,n)
    {
        vis[i]=0;
    }
    fill(d+1,d+n+1,0);
    rep(i,1,n)
    {
        dp[i]=1;
    }
    huan.clear();
}

///////////////////////////////////

int main()
{
    ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);//交互题请删除本行
   // freopen("ain.txt", "r", stdin); freopen("aout.txt", "w", stdout);
    
    cin>>tt;
    while (tt--)
    {
        cin>>n>>m;
        init();
        rep(i,1,m)
        {
            int x,y;
            cin>>x>>y;
            v[x].pb(y);
            v[y].pb(x);
            d[x]++;
            d[y]++;
        }

        //tree
        if(m==n-1)
        {
            cout<<"YES"<<endl;
            continue;
        }
        //more 
        if(m>n)
        {
            cout<<"NO"<<endl;
            continue;
        }

        queue<int > q;
        rep(i,1,n)
        {
            if(d[i]==1)
            {
                q.push(i);
            }
        }

        while (q.size())
        {
            int u=q.front();
            vis[u]=1;
            q.pop();
            for(auto i:v[u])
            {
                d[i]--;
                if(d[i]==1)
                {
                    q.push(i);
                }
            }
        }

        
        
        rep(i,1,n)
        {
            if(vis[i]==0)
            {
                vis[i]=1;
                yu(i);
                break;
            }
        }

        fill(vis+1,vis+n+1,0);
        for(auto i:huan)
        {
            vis[i]=1;
        }

        for(auto i:huan)
        {
            dfs(i);
        }



        bool flag=judge();
        if(flag)
        {
            cout<<"YES";
        }
        else
        {
            cout<<"NO";
        }
        cout<<endl;


    }
    
    


    return 0;
}

詳細信息

Test #1:

score: 100
Accepted
time: 2ms
memory: 7668kb

input:

4
7 6
1 2
2 3
3 4
4 5
5 6
3 7
3 3
1 2
2 3
3 1
5 5
1 2
2 3
3 4
4 1
1 5
1 0

output:

YES
YES
NO
YES

result:

ok 4 token(s): yes count is 3, no count is 1

Test #2:

score: -100
Wrong Answer
time: 42ms
memory: 5720kb

input:

33192
2 1
1 2
3 2
1 3
2 3
3 3
1 2
1 3
2 3
4 3
1 4
2 4
3 4
4 3
1 3
1 4
2 4
4 4
1 3
1 4
2 4
3 4
4 4
1 3
1 4
2 3
2 4
4 5
1 3
1 4
2 3
2 4
3 4
4 6
1 2
1 3
1 4
2 3
2 4
3 4
5 4
1 5
2 5
3 5
4 5
5 4
1 4
1 5
2 5
3 5
5 5
1 4
1 5
2 5
3 5
4 5
5 5
1 4
1 5
2 4
3 5
4 5
5 5
1 4
1 5
2 4
2 5
3 5
5 6
1 4
1 5
2 4
2 5
3 ...

output:

YES
YES
YES
YES
YES
NO
YES
NO
NO
YES
YES
NO
NO
NO
NO
NO
NO
YES
NO
NO
NO
NO
YES
NO
NO
NO
NO
NO
NO
NO
YES
YES
NO
YES
YES
NO
NO
NO
NO
NO
NO
NO
NO
NO
YES
NO
NO
NO
YES
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
YES
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
YES
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
NO
...

result:

wrong answer expected YES, found NO [39th token]