ZOJ 1015 弦图判定

一些定义:

弦图是一种特殊图:它的所有极小环都只有3个顶点。

单纯点：该顶点与其邻接点在原图中的导出子图是一个完全图。

图G的完美消去序列：一个顶点序列a₁a₂a₃...a_n,使得对于每个元素a_i，a_i在a_i、a_i+1、a_i+2...a_n的导出子图中是一个单纯点。

弦图有一个性质：任何一个弦图都至少存在一个单纯点（该点和其邻接点组成一个完全图）

弦图另一个性质：一个图是弦图当且仅当其存在完美消去序列。（归纳证明）

最大势算法(msc）：若原图是弦图，则该算法计算出的序列是完美消去序列。

算法大致思想：从后往前计算序列，每次选择点v作为序列中的元素，v是还未选的点中与已经选了的点连边最多的点。

然后检查该序列是否是完美消去序列。

请看陈丹琦的ppt：《弦图与区间图》

BZOJ:

/**************************************************************
    Problem: 1242
    User: idy002
    Language: C++
    Result: Accepted
    Time:544 ms
    Memory:1816 kb
****************************************************************/
 
#include <cstdio>
#include <cstring>
#define N 1010
#define M N*N*2
 
int n, m;
bool c[N][N];
int qu[N], inq[N], dgr[N];
int stk[N], top;
 
void msc() {
    dgr[0] = -1;
    for( int i=n; i>=1; i-- ) {
        int s = 0;
        for( int u=1; u<=n; u++ ) 
            if( !inq[u] && dgr[u]>dgr[s] ) s=u;
        qu[i] = s;
        inq[s] = true;
        for( int u=1; u<=n; u++ )
            if( !inq[u] && c[s][u] ) dgr[u]++;
    }
}
bool check() {
    for( int i=n; i>=1; i-- ) {
        int s=qu[i];
        top = 0;
        for( int j=i+1; j<=n; j++ )
            if( c[s][qu[j]] ) stk[++top] = qu[j];
        if( top==0 ) continue;
        for( int j=2; j<=top; j++ )
            if( !c[stk[1]][stk[j]] ) return false;
    }
    return true;
}
int main() {
    scanf( "%d%d", &n, &m );
    for( int i=1,u,v; i<=m; i++ ) {
        scanf( "%d%d", &u, &v );
        c[u][v] = c[v][u] = 1;
    }
    msc();
    printf( "%s
", check() ? "Perfect" : "Imperfect" );
}

 ZOJ:

#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#define maxn 1010
using namespace std;

int n, m;
vector<int> g[maxn];
bool connect[maxn][maxn];

int id[maxn];
int label[maxn];
int seq[maxn];

struct Stat {
    int lab, u;
    Stat( int lab, int u ) : lab(lab), u(u) {}
    bool operator<( const Stat & b ) const { 
        return lab<b.lab;
    }
};
void mcs() {
    priority_queue<Stat> pq;
    memset( label, 0, sizeof(label) );
    memset( id, 0, sizeof(id) );
    for( int u=1; u<=n; u++ ) pq.push(Stat(0,u));

    for( int i=n; i>=1; i-- ) {
        while( id[pq.top().u] ) pq.pop();
        int u = pq.top().u;
        pq.pop();
        id[u] = i;
        for( int t=0; t<g[u].size(); t++ ) {
            int v = g[u][t];
            if( !id[v] ) {
                label[v]++;
                pq.push( Stat(label[v],v) );
            }
        }
    }
    for( int u=1; u<=n; u++ ) 
        seq[id[u]] = u;
}

bool check() {
    vector<int> c;
    for( int i=1; i<=n; i++ ) {
        int u = seq[i];
        c.clear();
        for( int t=0; t<g[u].size(); t++ ) {
            int v = g[u][t];
            if( id[v]>id[u] ) 
                c.push_back(v);
        }
        if( c.empty() ) continue;
        int sc = c[0];
        for( int t=1; t<c.size(); t++ ) 
            if( id[c[t]]<id[sc] ) sc=c[t];
        for( int t=0; t<c.size(); t++ ) {
            int v = c[t];
            if( v==sc ) continue;
            if( !connect[sc][v] ) return false;
        }
    }
    return true;
}
void init( int n ) {
    memset( connect, false, sizeof(connect) );
    for( int u=1; u<=n; u++ ) g[u].clear();
}
int main() {
    while(1) {
        scanf( "%d%d", &n, &m );
        if( n==0 && m==0 ) return 0;
        init(n);
        for( int i=1,u,v; i<=m; i++ ) {
            scanf( "%d%d", &u, &v );
            connect[u][v] = connect[v][u] = true;
            g[u].push_back(v);
            g[v].push_back(u);
        }
        mcs();
        printf( "%s

", check() ? "Perfect" : "Imperfect" );
    }
}

 暴力:每次找单纯点,删掉,再找,如果能删完就说明是.

O(n^4*...)

#include <cstdio>
#include <vector>
#include <set>
#define N 110
#define foreach(it,s) for( typeof(s.begin()) it=s.begin(); it!=s.end(); it++ )
using namespace std;

int n, m;
set<int> s;
set<int> g[N];

bool find_erase() {
    foreach( u, s ) {
        vector<int> vc;
        foreach( v, g[*u] ) 
            vc.push_back(*v);
        bool ok = true;
        for( int a=0; a<vc.size() && ok; a++ ) 
            for( int b=a+1; b<vc.size() && ok; b++ )
                if( g[vc[a]].count(vc[b])==0 ) 
                    ok = false;
        if( ok ) {
            s.erase(*u);
            for( int t=0; t<g[*u].size(); t++ )
                g[vc[t]].erase(*u);
            return true;
        }
    }
    return false;
}
int main() {
    scanf( "%d%d", &n, &m );
    for( int i=1; i<=n; i++ )
        s.insert(i);
    for( int i=1,u,v; i<=m; i++ ) {
        scanf( "%d%d", &u, &v );
        if( g[u].count(v) ) continue;
        g[u].insert(v);
        g[v].insert(u);
    }
    for( int t=1; t<=n; t++ ) {
        if( !find_erase() ) {
            printf( "Imperfect
" );
            return 0;
        }
    }
    printf( "Perfect
" );
}