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[] = -;
     for( int i=n; i>=; i-- ) {
         int s = ;
         for( int u=; u<=n; u++ )
             if( !inq[u] && dgr[u]>dgr[s] ) s=u;
         qu[i] = s;
         inq[s] = true;
         for( int u=; u<=n; u++ )
             if( !inq[u] && c[s][u] ) dgr[u]++;
     }
 }
 bool check() {
     for( int i=n; i>=; i-- ) {
         int s=qu[i];
         top = ;
         for( int j=i+; j<=n; j++ )
             if( c[s][qu[j]] ) stk[++top] = qu[j];
         if( top== ) continue;
         for( int j=; j<=top; j++ )
             if( !c[stk[]][stk[j]] ) return false;
     }
     return true;
 }
 int main() {
     scanf( "%d%d", &n, &m );
     for( int i=,u,v; i<=m; i++ ) {
         scanf( "%d%d", &u, &v );
         c[u][v] = c[v][u] = ;
     }
     msc();
     printf( "%s\n", 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, , sizeof(label) );
     memset( id, , sizeof(id) );
     for( int u=; u<=n; u++ ) pq.push(Stat(,u));

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

 bool check() {
     vector<int> c;
     for( int i=; i<=n; i++ ) {
         int u = seq[i];
         c.clear();
         for( int t=; 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[];
         for( int t=; t<c.size(); t++ )
             if( id[c[t]]<id[sc] ) sc=c[t];
         for( int t=; 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=; u<=n; u++ ) g[u].clear();
 }
 int main() {
     while() {
         scanf( "%d%d", &n, &m );
         if( n== && m== ) return ;
         init(n);
         for( int i=,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\n\n", 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=; a<vc.size() && ok; a++ )
             for( int b=a+; b<vc.size() && ok; b++ )
                 if( g[vc[a]].count(vc[b])== )
                     ok = false;
         if( ok ) {
             s.erase(*u);
             for( int t=; t<g[*u].size(); t++ )
                 g[vc[t]].erase(*u);
             return true;
         }
     }
     return false;
 }
 int main() {
     scanf( "%d%d", &n, &m );
     for( int i=; i<=n; i++ )
         s.insert(i);
     for( int i=,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=; t<=n; t++ ) {
         if( !find_erase() ) {
             printf( "Imperfect\n" );
             return ;
         }
     }
     printf( "Perfect\n" );
 }