Test 1022
T1 AERODROM (二分答案
TimeLimit: 1000MS
Memory Limit: 32768KB
\(N\)个登机口，办理登机业务，第\(i\)个窗口的单位办理时间为\(T_i\)，\(M\)个人办理登机业务，他们可以选择最佳的方案，不考虑换人和换窗口的时间，所有窗口是同时计时的，即同时开始办理业务，请输出所有人都登机的最少时间。
如样例\(1\)：
2个窗口，6个人，第一个窗口的单位时间是7,第二个是10, 一二个人分别在两个窗口办理，7秒时第三个人可在第一个窗口开始办理，10秒时，第四人开始在窗口二办理，时间14时，第五人一窗口。在时间20，窗口2可以使用，如果第六人在此办理，总时间将是30秒，如果等1秒在一窗口办理，则总时间是28秒。
输入：
第一行两个正整数 \(N (1 ≤ N ≤ 100 000)\),
窗口数,和\(M (1 ≤ M ≤ 1 000 000 000)\), 登机人数。
以下每行一个数\(T_i\)表示第\(i\)个窗口的单位办理时间 \((1 ≤ Ti ≤ 10^9)\).
输出 :
一个数，最少办理时间。
input
2 6
7
10
output
28
input
7 10
3
8
3
6
9
2
4
output
8
时间就是每个窗口时间的最大值，求最大值的最小值，用二分答案；
\(Code\)
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=100005,M=1000000005;
int n,m;
int a[N],mins=0x7fffffff;
ll l,r;
inline int read()
{
int x=0,f=1;char st=getchar();
while(st<'0'||st>'9'){if(st=='-') f=-1;st=getchar();}
while(st>='0'&&st<='9') x=x*10+st-'0',st=getchar();
return x*f;
}
inline bool check(ll mid)
{
ll tmp=0;
for(int i=1;i<=n;i++)
{
tmp+=mid/a[i];
if(tmp>=m) return 1;
}
return 0;
}
int main()
{
freopen("aerodrom.in","r",stdin);
freopen("aerodrom.out","w",stdout);
n=read();m=read();
for(int i=1;i<=n;i++)
{
a[i]=read();
mins=min(mins,a[i]);
}
r=(ll)mins*m;
while(l<r)
{
ll mid=l+r>>1;
if(check(mid)) r=mid;
else l=mid+1;
}
printf("%lld",l);
fclose(stdin);
fclose(stdout);
return 0;
}
T2 HERKABE (trie
TimeLimit: 1000MS
Memory Limit: 32768KB
给出\(N\)个由大写字母构成的名字，现在要求对名字排序，要求有相同前缀的单词要排在一起，问共有多少种排法。
输入：
第一行一个正整数 \(N (3 ≤ N ≤ 3000)\), 名字的个数。
以下N行，每行一个名字长度界于\(1\)到 \(3000\) 名字无重复且按任意顺序给出。.
输出：
一行一个正整数表示方案总数。由于数据大要求输出模\(1000 000 007\)的值.
input
3
IVO
JASNA
JOSIPA
output
4
input
5
MARICA
MARTA
MATO
MARA
MARTINA
output
24
input
4
A
AA
AAA
AAAA
output
8
这道题目有故意卡内存之嫌；
先理解题目；
第一个样例对我们没有太大帮助；
第二个样例；
最长的公共前缀是MART,所以MARTA，MARTINA必须排在一起；有\(2!\)种
把这两个看成一个整体\(x\),接下来的最长公共前缀是MAR,所以\(x\),MARICA，MARA必须放在一起；有\(3!\)种；
再把这些看成一个整体\(y\),接下来的最长公共前缀是MA，所以\(y\),MATO必须放在一起；有\(2!\)种；
总共有\(2！*2！*3！=24\)种；
发现，这不就是一颗\(trie\)树吗;
其实答案就是\(trie\)数中，每个节点的子节点个数的阶乘的乘积；
然后写棵\(trie\)就可以了
然后第三个样例过不了，当某个字符串是另一个字符串的前缀时，我们发现这一个字符串是没有结束符的，我们可以在每个字符串后面加一个\('Z'+1\)，这样就不会有任何两个字符串互为前缀了；
然后就会\(MLE\);
时间复杂度是\(O(n^2)\)
优化
- 用vector 代替字符集；
- 排序后模拟\(trie\)树；
这种办法比较好想，想用\(O(n^2logn)\)按字典序排序，有相同前缀的一定在一起；
我们一位一位搜，找下一位有多少种不同的字符(就是\(trie\)树中这个节点的子节点个数)，过程中统计子节点个数的阶乘，当只有一个子节点时返回；
与\(trie\)树时间复杂度一样，这部分是\(O(n^2)\);
\(Code\)
#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int N=3005,mod=1000000007;
int n;
struct skr
{
char s[N];
int len;
bool operator<(skr w)const
{
for(int i=0;i<max(len,w.len);i++)
if(s[i]<w.s[i]) return 1;
else if(s[i]>w.s[i]) return 0;
}
}a[N];
ll ans=1,nm[N];
inline int read()
{
int x=0,f=1;char st=getchar();
while(st<'0'||st>'9'){if(st=='-') f=-1;st=getchar();}
while(st>='0'&&st<='9') x=x*10+st-'0',st=getchar();
return x*f;
}
inline void dfs(int x,int l,int r) //搜第x位，搜索区间是l~r
{
if(l>=r) return ;
int num=0;
int L=l,R=l;
for(int i=l;i<=r;i++)
{
if(a[i].s[x]==a[L].s[x]) R=i;
else
{
num++;
dfs(x+1,L,R);
L=i;
}
}
num++;
if(L==r) R=r;
dfs(x+1,L,R);
ans=ans*nm[num]%mod;
}
int main()
{
freopen("herkabe.in","r",stdin);
freopen("herkabe.out","w",stdout);
n=read();
for(int i=1;i<=n;i++)
{
scanf("%s",a[i].s);
a[i].len=strlen(a[i].s);
a[i].s[a[i].len]='Z'+1;
a[i].len++;
}
nm[0]=1;
for(int i=1;i<=n;i++)
nm[i]=nm[i-1]*i%mod;
sort(a+1,a+1+n);
dfs(0,1,n);
printf("%lld",ans);
fclose(stdin);
fclose(stdout);
return 0;
}
- 压缩\(trie\)树
实际上是压缩尾缀，将没有分叉的节点(单链)合成一个节点，这样建成的\(trie\)树，除了叶子结点，每个节点有最少\(2\)个子节点，最多有字符集大小个子节点。节点个数是字符串个数等级的，可以大规模压缩空间；
比如这是一棵压缩了的\(trie\)树：
（图片来自网络
T2 HERKABE (扩展域并查集
TimeLimit: 1000MS
Memory Limit: 32768KB
给出一个数字\(N\)表示有\(N\)个\(32\)位无符号数\((0\sim 2^{32}-1)\)，我们可以进行如下两个操作
操作\(1\)表示把第\(K\)个数后\(M\)位转到最前面；
操作\(2\)表示把第\(K\)个数和第\(L\)个数进行\(XOR\)运算。
我们最初不知道这\(N\)个数的值，但我们知道每一个\(2\)操作后的结果，请推出每一个数最初的值。如果有多种解，输出字典序最小的。（如果第\(K-1\)个数一样，则第\(K\)个数小的则小）
输入 ：
第一行两个正整数: \(N (2 ≤ N ≤ 100 000)\), 变量的个数。和 \(E (1 ≤ E ≤ 100 000)\), 操作的个数。
接下来\(E\)行，按执行的顺序给出每一个操作和操作后的答案。 \((1 ≤ K, L ≤ N, 0 ≤ M < 32)\).
每次操作的答案大小\(0\) 到$ 2^{32}– 1$,二进制异或的值是按\(10\)进制给出的。
输出：
一行，\(N\)个值，表示变量最初的可能值。
如果找不到合适的方案，则输出\(-1\)。
input
3 3
2 1 2
1
2 1 3
2
2 2 3
3
output
0 1 2
input
4 6
2 4 2
3
2 4 1
6
1 3 1
2 3 1
2
1 2 2
2 2 3
7
output
5 0 14 3
input
5 6
2 4 2
10
2 5 3
2
2 2 3
1
2 1 4
3
1 3 1
2 3 4
2147483663
output
15 6 7 12 5
我们先把\(n\)个数拆成\(n\)个二进制串；
从第二种个操作入手，如果得到的结果第\(i\)位是\(1\)，意味着第\(K\)个和第\(L\)个数的第\(i\)位是不一样的，否则是一样的；
那\(1\)操作呢，我们发现它只是把我们的二进制串移了个位置，可以记录一个\(r[i]\)表示第\(i\)个串被右移了多少位；
这样我们得到了很多约束条件，要求一种构造方法，使每个节点有一个合适的赋值（\(0/1\)）;
这就是\(2-SAT\)模型了，但这道题又会\(MLE\);
这类问题也可以用并查集扩展域来做，应为只有两种取值，我们视每个数的每一位为一个节点，每个节点有两个域,\(0\)域和\(1\)域；
如果两个点相同，则把他们的，\(0\)域相连，\(1\)域相连；
代表其中一个节点选\(0(或1)\)，另一个必须选\(0(或1)\);
若不同，则\(1\)域与\(0\)域相连，\(0\)域与\(1\)域相连；
如果有一个节点的\(0\)域与\(1\)域相连了，则输出\(-1\);
确保了有合法构造方案之后，我们可以用贪心得到字典序最小的构造方案；
从第一个数的最高位开始；
优先选\(0\)，如果其\(0\)域的根被取了与它所在域合适的值，当前节点就取\(0\);
\(1\)域同样；
如果两个域都没有合适的值，当前节点优先选\(0\)，并应当把其\(0\)域根节点的取值赋成这个根节点所在域的值，相当于把这个集合的节点都赋了值；
\(Code\)
#include<bits/stdc++.h>
#define c n*32
#define ll long long
using namespace std;
const int N=100005;
int n,e,opt;
char ans[N][35];//卡内存
int r[N];
int fa[N*32*2],f1,f2;
ll sq[35],ra;
inline int read()
{
int x=0,f=1;char st=getchar();
while(st<'0'||st>'9'){if(st=='-') f=-1;st=getchar();}
while(st>='0'&&st<='9') x=x*10+st-'0',st=getchar();
return x*f;
}
inline int get(int x)
{
return fa[x]==x?x:fa[x]=get(fa[x]);
}
int main()
{
freopen("procesor.in","r",stdin);
freopen("procesor.out","w",stdout);
n=read();e=read();
memset(fa,-1,sizeof fa);
for(int i=0;i<=n*32*2;i++)
fa[i]=i;
for(int i=1;i<=e;i++)
{
opt=read();
if(opt==1)
{
int x=read(),y=read();
r[x]=(r[x]+y)%32;
}
else
{
int x=read(),y=read(),z;
scanf("%lld",&z);
for(int j=0;j<32;j++)
if((z>>j)&1)
{
int x1=(j+r[x])%32,x2=(j+r[y])%32;
f1=get((x-1)*32+x1),f2=get((y-1)*32+x2+c);
if(f1!=f2)
fa[f1]=f2;
f1=get((x-1)*32+x1+c),f2=get((y-1)*32+x2);
if(f1!=f2)
fa[f1]=f2;
}
else
{
int x1=(j+r[x])%32,x2=(j+r[y])%32;
f1=get((x-1)*32+x1),f2=get((y-1)*32+x2);
if(f1!=f2)
fa[f1]=f2;
f1=get((x-1)*32+x1+c),f2=get((y-1)*32+x2+c);
if(f1!=f2)
fa[f1]=f2;
}
}
}
for(int i=0;i<32*n;i++)
{
f1=get(i),f2=get(i+c);
if(f1==f2)
{
printf("-1");
fclose(stdin);
fclose(stdout);
return 0;
}
}
for(int j=1;j<=n;j++)
for(int i=0;i<32;i++)
ans[j][i]=2;//初始
for(int j=1;j<=n;j++)
for(int i=31;i>=0;i--)
{
bool fl1=0,fl2=0;
f1=get((j-1)*32+i);//0
f2=get((j-1)*32+i+c);//1
if(f1>=c) f1-=c,fl1=1;
if(f2>=c) f2-=c,fl2=1;
if(ans[(f1)/32+1][f1%32]==(fl1==1))
{
ans[j][i]=0;
}
else
{
if(ans[(f2)/32+1][f2%32]==(fl2==1))
ans[j][i]=1;
else
{
ans[j][i]=0;
ans[(f1)/32+1][f1%32]=fl1;
}
}
}
sq[0]=1;
for(int i=1;i<=32;i++)
sq[i]=sq[i-1]*2;
for(int j=1;j<=n;j++)
{
ra=0;
for(int i=0;i<32;i++)
{
ra=ra+sq[i]*ans[j][i];
}
printf("%lld ",ra);
}
fclose(stdin);
fclose(stdout);
return 0;
}
