辛亏我没考，不然铁定掉 rating。
T1
T1 比较水，但是坑点比较多。挂了两次，第一次是没有处理前导 (0)，第二次是没有处理后缀非数字字符。
代码：
#include<bits/stdc++.h>
#define dd double
#define ld long double
#define ll long long
#define uint unsigned int
#define ull unsigned long long
#define N number
#define M number
using namespace std;
const int INF=0x3f3f3f3f;
template<typename T> inline void read(T &x) {
x=0; int f=1;
char c=getchar();
for(;!isdigit(c);c=getchar()) if(c == '-') f=-f;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
x*=f;
}
string s;
bool op=1;
ll a[5],tail;
int main(){
cin>>s;int len=s.length();
for(int i=0,j;i<=len-1;){
if(s[i]<'0'||s[i]>'9'){
if(tail==4) op=0;
if(s[i]!='.') op=0;
if(i>0&&(s[i-1]<'0'||s[i-1]>'9')) op=0;
i++;
continue;
}
tail++;
bool pd=1;
for(j=i;j<=len-1;j++){
if(s[j]=='0'&&pd) op=0;
if(s[j]!='0') pd=0;
if(s[j]>='0'&&s[j]<='9') a[tail]=1ll*a[tail]*10+s[j]-'0';
else break;
}
i=j;
}
for(int i=1;i<=tail;i++) if(a[i]>255){a[i]=255;op=0;}
if(op){printf("YES
");return 0;}
printf("NO
");
for(int i=1;i<=tail;i++){
printf("%lld",a[i]);if(i!=tail) putchar('.');
}
return 0;
}
T2
也比较水，只需要看前导 P 和 A，然后记录一下前导 P 的数量看能不能消即可。挂了一次，挂在前导 P 不应该清零。
代码：
#include<bits/stdc++.h>
#define dd double
#define ld long double
#define ll long long
#define uint unsigned int
#define ull unsigned long long
#define N 10010
#define M number
using namespace std;
const int INF=0x3f3f3f3f;
template<typename T> inline void read(T &x) {
x=0; int f=1;
char c=getchar();
for(;!isdigit(c);c=getchar()) if(c == '-') f=-f;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
x*=f;
}
int cnt=0,ans=0,tot;
char s[N];
int main(){
scanf("%s",s);int len=strlen(s);
for(int i=0;i<=len-1;i++){
if(s[i]=='A'){cnt++;}
if(s[i]=='P'){
if(cnt){cnt--;ans++;}
else{
tot++;
if(tot==2){tot=0;ans++;}
}
}
}
printf("%d
",len-ans*2);
}
T3
T3 主要难度在于菱形的判断，稍加分析之后不难看出，我们记 (bit) 为若干 bitset，其中如果有一位为 (1) 表示两个点他们不互相派生且存在一个点可以派生出这两个点。
那么判断可不可以的时候我们只需要枚举直接继承点，构造一个 bitset，全部交一遍，看是否有交集就可以判断出是否可行。
我们考虑如何维护 (bit)，我们在记一个 (f)，同样也是一个 bitset，不过这个表示的是能够到达某个点的所有点所在集合，注意我们认为自身可以到达自身。显然我们可以把新加的点的 (f) 数组处理出来。然后我们枚举所有点，如果这个点到达不了当前点，并且他们的 (f) 值有交集，那么我们就相应更改 (bit)。复杂度为 (O(frac{n^3}{w}))
不过这个题还可以优化到 (O(n^2log n)) 这里简单的提一句。
我们假设当前的这个语句为 (k:p_1,p_2,...p_k;)，我们把后面这些 (p) 按照声明顺序从大到小排序。显然只有声明顺序小的才能继承出声明顺序大的。 我们一次处理每一个 (p)，维护一个 (R) 表示能到达 (k) 的节点集合。对于 (p_i)，如果 (R) 里面这个位置已经为 (1)，那么我们就不管，因为能够到达 (p_i) 也肯定已经在 (R) 中了，否则，我们把 (R) 与能够到达 (p_i) 的集合合并，如果有交，就说明一定出现了菱形。
我们看一下时间复杂度，这个 (R) 一共有 (n) 个位置，所以复杂度均摊下来是 (O(n))，一共做 (n) 次，所以复杂度为 (O(n^2))。时间复杂度瓶颈在排序。如果用桶排，理论更优，但是常数较大，实际时间不如直接 sort。
代码：
#include<bits/stdc++.h>
#define dd double
#define ld long double
#define ll long long
#define uint unsigned int
#define ull unsigned long long
#define N 1010
#define M number
using namespace std;
// #define fre
const int INF=0x3f3f3f3f;
template<typename T> inline void read(T &x) {
x=0; int f=1;
char c=getchar();
for(;!isdigit(c);c=getchar()) if(c == '-') f=-f;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
x*=f;
}
int n,tail=0;
map<string,int> Map;
bitset<1010> bit[N],f[N];
string s[N],ss;
int main(){
#ifdef fre
freopen("my.in","r",stdin);
freopen("my.out","w",stdout);
#endif
read(n);
for(int i=1;i<=n;i++){
cin>>ss;int j=0;cin>>s[j];
while(s[j][0]!=';') cin>>s[++j];j--;
bool op=1;
if(Map.find(ss)!=Map.end()){printf("greska
");continue;}
for(int k=1;k<=j;k++) if(Map.find(s[k])==Map.end()){op=0;break;}
if(!op){printf("greska
");continue;}
bitset<1010> sum;sum.reset();
for(int k=1;k<=j;k++) sum[Map[s[k]]]=1;
for(int k=1;k<=j;k++) if((sum&bit[Map[s[k]]]).any()){op=0;break;}
if(!op){printf("greska
");continue;}
printf("ok
");++tail;Map[ss]=tail;f[tail][tail]=1;
for(int k=1;k<=j;k++) f[tail]|=f[Map[s[k]]];
for(int k=1;k<=tail-1;k++){
if(f[tail][k]==0&&(f[k]&f[tail]).any()) bit[tail][k]=1;
}
}
}
T4
毒瘤题目。谢老板nb。
首先不难发现，(k-degree) 子图一定包含于 ((k-1)-degree) 子图中，并且子图的数量本来就不多，这启示我们这道题应该是需要大力维护出这些子图的信息出来。
那么首先我们需要维护出每一个点最多能存在于那个子图中，即把 (k) 最大化的 (k-degree) 子图中。假设我们已经求出来了，并且存到了 (vis) 这个数组里面。我们下面称这个值为这个点的标记。
我们考虑从标记最大的点开始，一层一层扩张，每次需要维护集合合并，我们考虑用并查集维护。
那么这个题分两个步骤，我们首先来看第一个步骤怎么做。
我们首先桶排所有的点，按照他们的度数，然后我们从小到大枚举每一个点，考察每一条边，如果对点的当前度数大于你的度数，你就把它的度数减 (1)，然后维护这个序列的有序性，维护方法就是维护值得分界线，这段代码如下：
inline void GetVis(){
for(int i=1;i<=n;i++) r[i].id=i,r[i].vis=D[i];
for(int i=1;i<=n;i++) c[r[i].vis]++;
for(int i=1;i<=n;i++) c[i]+=c[i-1];
for(int i=n;i>=1;i--) Rank[i]=c[r[i].vis]--;
for(int i=1;i<=n;i++) a[Rank[i]]=r[i];
for(int i=1;i<=n-1;i++) if(a[i].vis!=a[i+1].vis) line[a[i].vis]=i;
for(int i=1;i<=n;i++){
for(int x=head[a[i].id];x;x=li[x].next){
int to=li[x].to;
if(a[Rank[to]].vis<=a[i].vis) continue;
a[Rank[to]].vis--;
int posi=line[a[Rank[to]].vis]+1;
line[a[Rank[to]].vis]++;
int id=a[posi].id;
swap(a[Rank[to]],a[Rank[id]]);
swap(Rank[to],Rank[id]);
}
}
for(int i=1;i<=n;i++) vis[a[i].id]=a[i].vis;
#ifdef debug
printf("here
vis: ");Print(vis);
#endif
}
我们考虑正确性。我们先考虑一种显然正确的方法。我们令 (k) 为当前最小度数，然后我们删除全部度数小于等于 (k) 的点，需要及时修改一些点的度数，直到剩下的图全是度数大于 (k) 的点。这些被删除的点的标记都为 (k)，我们考虑进一步增大 (k)。一直到整张图被删完。但是这种做法其实复杂度不对，原因就是我们可能会保留一些点较长时间，复杂度上界是根号的，但是到不了这个级别，但也绝对不是线性。我们考虑线性怎么做。
显然我们删除度数为 (k) 的点会改变一些点的度数，如果这些点原本的度数就已经小于等于 (k)（有可能被其他点删除导致小于 (k)），那么其实不管怎样这个点都将会在这一轮中删除。有影响的是那些大于 (k) 的度数，他们可能会被先删。我们一开始介绍的那种方法其实就是模拟了这一点，假设当前我们枚举的位置的度数为 (k)，那么这个 (k) 一定是其标记，因为只有小于 (k) 的那些才能够更新他们。我们检查其每一条出边，我们可以让一些度数大的提早被删除。做完后剩下的度数就是标记。
有了标记之后我们怎么做？我们考虑把所有点按照标记排序，我们从大标记开始处理。考虑用并查集进行连通块之间的合并，我们记录每个连通块的点内度数之和，点数，边数之和。其中，前两个信息都是可以直接预处理合并的，我们考虑这个边数之和如何合并。
我们首先把所有点按照标记合并，我们枚举每个点，然后枚举每一条出边，如果对点在该点左侧，我们不管，这样可以保证每条边只被遍历一次，我们考虑该点与对点所在连通块，若不在同一个连通块，我们把连通块合并，边数当然也合并，然后我们把这条边的影响加上。
考虑正确性，其实是比较显然的，因为你每条边只被遍历一次，每次遍历会给在相应的连通块上进行贡献。
每次枚举到分界点后我们进行修改答案，看能不能更优，因为可能不连通，我们需要枚举所有点。
代码：
#include<bits/stdc++.h>
#define dd double
#define ld long double
#define ll long long
// #define int long long
#define uint unsigned int
#define ull unsigned long long
#define N 5000100
#define M number
using namespace std;
// #define fre
// #define debug
const int INF=0x3f3f3f3f;
template<typename T> inline void read(T &x) {
x=0; int f=1;
char c=getchar();
for(;!isdigit(c);c=getchar()) if(c == '-') f=-f;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
x*=f;
}
template<typename T> inline T Min(T a,T b){return a<b?a:b;}
template<typename T> inline T Max(T a,T b){return a<b?b:a;}
int ns[N],ms[N],ds[N],maxk,mink;
//最终答案。
ll ans=-INF,ansk;
int fa[N];
inline int Find(int x){
return x==fa[x]?x:Find(fa[x]);
}
struct edge{
int to,next;
inline void intt(int to_,int ne_){to=to_;next=ne_;}
}li[N<<1];
int head[N],tail,n,m,mm,nn,bb,d[N],D[N];
int vis[N];//打标记，有没有被删除，如果有，是在 k 等于几的时候被删除的。
int c[N],Rank[N],line[N],linetail;
struct rode{
int vis,id;
}r[N],a[N];
struct Graph{
//Init the graph
inline void Init(){
read(n);read(m);read(mm);read(nn);read(bb);
for(int i=1;i<=m;i++){int from,to;read(from);read(to);Add(from,to);Add(to,from);}
#ifdef debug
printf("here
");
#endif
}
//add an edge
inline void Add(int from,int to){
li[++tail].intt(to,head[from]);
head[from]=tail;D[to]++;
}
//这个函数会求的 vis 数组，是每个位置的标记。
inline void GetVis(){
for(int i=1;i<=n;i++) r[i].id=i,r[i].vis=D[i];
for(int i=1;i<=n;i++) c[r[i].vis]++;
for(int i=1;i<=n;i++) c[i]+=c[i-1];
for(int i=n;i>=1;i--) Rank[i]=c[r[i].vis]--;
for(int i=1;i<=n;i++) a[Rank[i]]=r[i];
for(int i=1;i<=n-1;i++) if(a[i].vis!=a[i+1].vis) line[a[i].vis]=i;
for(int i=1;i<=n;i++){
for(int x=head[a[i].id];x;x=li[x].next){
int to=li[x].to;
if(a[Rank[to]].vis<=a[i].vis) continue;
a[Rank[to]].vis--;
int posi=line[a[Rank[to]].vis]+1;
line[a[Rank[to]].vis]++;
int id=a[posi].id;
swap(a[Rank[to]],a[Rank[id]]);
swap(Rank[to],Rank[id]);
}
}
for(int i=1;i<=n;i++) vis[a[i].id]=a[i].vis;
#ifdef debug
printf("here
vis: ");Print(vis);
#endif
}
inline void Print(int *a){
for(int i=1;i<=n;i++) printf("%lld ",a[i]);puts("");
}
inline void PreWork(){
fill(c+1,c+n+1,0);fill(Rank+1,Rank+n+1,0);
for(int i=1;i<=n;i++) c[vis[i]]++;
for(int i=1;i<=n;i++) c[i]+=c[i-1];
for(int i=n;i>=1;i--) Rank[i]=c[vis[i]]--;
for(int i=1;i<=n;i++) c[Rank[i]]=i;
for(int i=1;i<=n;i++) ns[i]=1,ds[i]=D[i];
}
inline void Solve(){
for(int i=1;i<=n;i++) fa[i]=i;
for(int i=n;i>=0;i--){
int now=c[i];
int fai=Find(now);
for(int x=head[now];x;x=li[x].next){
int to=li[x].to;
if(Rank[to]<Rank[now]) continue;
int fato=Find(to);
if(fai!=fato){
if(ns[fai]<=ns[fato]) swap(fato,fai);
fa[fato]=fai;ns[fai]+=ns[fato];ds[fai]+=ds[fato];ms[fai]+=ms[fato];
}
ms[fai]++;
}
if(vis[now]!=vis[c[i-1]]){
for(int j=i;j<=n&&vis[c[j]]==vis[now];j++){
int nowfa=Find(c[j]);
long long val=1ll*mm*ms[nowfa]-1ll*nn*ns[nowfa]+1ll*bb*(ds[nowfa]-(ms[nowfa]<<1));
if(val>ans){ans=val;ansk=vis[now];}
}
}
}
}
}g;
signed main(){
#ifdef fre
freopen("my.in","r",stdin);
freopen("my.out","w",stdout);
#endif
g.Init();g.GetVis();g.PreWork();g.Solve();
printf("%lld %lld
",ansk,ans);
return 0;
}