Codeforces Round #533 (Div. 2) E 最大独立集

知识点

最大独立集（set） = 补图的最大团（clique ）

最小顶点覆盖 + 最大独立集 = V

E. Helping Hiasat

time limit per test

2 seconds

memory limit per test

256 megabytes

input

standard input

output

standard output

Hiasat registered a new account in NeckoForces and when his friends found out about that, each one of them asked to use his name as Hiasat's handle.

Luckily for Hiasat, he can change his handle in some points in time. Also he knows the exact moments friends will visit his profile page. Formally, you are given a sequence of events of two types:

• 11 — Hiasat can change his handle.
• 22 ss — friend ss visits Hiasat's profile.

The friend ss will be happy, if each time he visits Hiasat's profile his handle would be ss.

Hiasat asks you to help him, find the maximum possible number of happy friends he can get.

Input

The first line contains two integers nn and mm (1≤n≤105,1≤m≤401≤n≤105,1≤m≤40) — the number of events and the number of friends.

Then nn lines follow, each denoting an event of one of two types:

• 11 — Hiasat can change his handle.
• 22 ss — friend ss (1≤|s|≤401≤|s|≤40) visits Hiasat's profile.

It's guaranteed, that each friend's name consists only of lowercase Latin letters.

It's guaranteed, that the first event is always of the first type and each friend will visit Hiasat's profile at least once.

Output

Print a single integer — the maximum number of happy friends.

Examples

input

Copy

5 3
1
2 motarack
2 mike
1
2 light

output

Copy

2

input

Copy

4 3
1
2 alice
2 bob
2 tanyaromanova

output

Copy

1

Note

In the first example, the best way is to change the handle to the "motarack" in the first event and to the "light" in the fourth event. This way, "motarack" and "light" will be happy, but "mike" will not.

In the second example, you can choose either "alice", "bob" or "tanyaromanova" and only that friend will be happy.

题意  m个朋友 n个操作

两种操作

1 Hiasat 可以修自己的id为任意值

2 Hiasat 得一个朋友查看id

当且仅当 他的朋友每次查看id都为自己的名字才是高兴的

解析    很容易想到两个1之间的朋友是互斥的 只能使其中一名朋友高兴，我们在互斥的朋友之间连一条无向边，从而转化成求无向图的最大独立集问题。

AC代码

 #include <bits/stdc++.h>
 #define pb push_back
 #define mp make_pair
 #define fi first
 #define se second
 #define all(a) (a).begin(), (a).end()
 #define fillchar(a, x) memset(a, x, sizeof(a))
 #define huan printf("\n")
 #define debug(a,b) cout<<a<<" "<<b<<" "<<endl
 #define ffread(a) fastIO::read(a)
 using namespace std;
 const int maxn = 1e5+;
 const int maxm = 1e4+;
 const int inf = 0x3f3f3f3f;
 const int mod = ;
 const double epx = 1e-;
 typedef long long ll;
 const ll INF = 1e18;
 const double pi = acos(-1.0);
 //head------------------------------------------------------------------
 int G[][];
 int ans,cnt[],group[],n,m,vis[];//ans表示最大团，cnt[N]表示当前最大团的节点数，group[N]用以寻找一个最大团集合
 map<string,int> pm;
 int tot = ;
 struct node
 {
     int op;
     string s;
 } Q[maxn];
 vector<int> v;
 bool dfs(int u,int pos)//u为当从前顶点开始深搜，pos为深搜深度（即当前深搜树所在第几层的位置）
 {
     int i,j;
     for(i=u+; i<=tot; i++) //按递增顺序枚举顶点
     {
         if(cnt[i]+pos<=ans)
             return ;//剪枝
         if(G[u][i])
         {
             // 与目前团中元素比较，取 Non-N(i)
             for(j=; j<pos; j++)
                 if(!G[i][vis[j]])
                     break;
             if(j==pos)
             {
                 // 若为空，则皆与 i 相邻，则此时将i加入到 最大团中
                 vis[pos]=i;//深搜层次也就是最大团的顶点数目，vis[pos] = i表示当前第pos小的最大团元素为i（因为是按增顺序枚举顶点 ）
                 if(dfs(i,pos+))
                     return ;
             }
         }
     }
     if(pos>ans)
     {
         for(i=; i<pos; i++)
             group[i] = vis[i]; // 更新最大团元素
         ans = pos;
         return ;
     }
     return ;
 }
 void maxclique()//求最大团
 {
     ans=-;
     for(int i=tot; i>; i--)
     {
         vis[]=i;
         dfs(i,);
         cnt[i]=ans;
     }
 }
 int main()
 {
     scanf("%d%d",&n,&m);
     for(int i=; i<=n; i++)
     {
         int op;
         string tmp;
         scanf("%d",&op);
         if(op==)
             Q[i].op = op;
         else
         {
             cin>>tmp;
             Q[i].op = op;
             Q[i].s = tmp;
             if(!pm[tmp])
                 pm[tmp] = ++tot;
         }
     }
     memset(G,inf,sizeof(G));
     Q[n+].op=;
     for(int i=; i<=n+; i++)
     {
         if(Q[i].op==)
         {
             for(int j=; j<v.size(); j++)
             {
                 for(int k=j+; k<v.size(); k++)
                 {
                     G[v[k]][v[j]] = ;
                     G[v[j]][v[k]] = ;
                 }
             }
             v.clear();
         }
         else
         {
             v.push_back(pm[Q[i].s]);
         }
     }
     maxclique();
     if(ans<)
         ans = ;
     printf("%d\n",ans);
     return ;
 }