//对于字符串比较多的要统计个数的,map被卡的情况下,直接用字典树
//很多题都是要用到节点下标来表示某个字符串
const int maxn =2e6+5;//如果是64MB可以开到2e6+5,尽量开大
int tree[maxn][30];//tree[i][j]表示节点i的第j个儿子的节点编号
bool flagg[maxn];//表示以该节点结尾是一个单词
int tot;//总节点数
void insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'0';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
flagg[root]=true;
}
bool find_(char *str)//查询操作,按具体要求改动
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'0';
if(!tree[root][id]) return false;
root=tree[root][id];
}
return true;
}
void init()//最后清空,节省时间
{
for(int i=0;i<=tot;i++)
{
flagg[i]=false;
for(int j=0;j<10;j++)
tree[i][j]=0;
}
tot=0;//RE有可能是这里的问题
}
HDU1251
题意就是统计出以某个字符串为前缀的单词数量,首先构建出trie树并记录每个节点的访问次数,然后在上面查询就好了,模板题。
HDU1251代码
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30];
int sum[maxn];
int tot;
void insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
sum[tree[root][id]]++;//记录节点访问次数
root=tree[root][id];
}
//root在此对应某个单词,一一对应
}
int find_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) return 0;
root=tree[root][id];
}
return sum[root];//返回当前字符串结尾节点的访问次数,也就是作为前缀的出现次数
}
char ss[maxn];
int main()
{
tot=0;
while(gets(ss))
{
if(ss[0]=='\0') break;
insert_(ss);
}
while(scanf("%s",ss)!=EOF)
{
printf("%d\n",find_(ss));
}
return 0;
}
HDU2072
题意就是出现的不同单词个数
直接把字符全部插入Trie树中,然后统计所有具有flagg标记的节点个数就好了。
也可以边插入边统计,如果当前字符串结尾下标已经被标记,就不对答案做贡献,否则ans++.
第二题代码
#include
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30];
bool flagg[maxn];
int tot;
void insert_(string str)
{
int len=str.size();
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
flagg[root]=true;
}
bool find_(string str)
{
int len=str.size();
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) return true;//该单词没有出现过
root=tree[root][id];
}
if(flagg[root]) return false;//出现过,不再算贡献
else return true;
}
string str1,str2;
int main()
{
ios::sync_with_stdio(false);
while(getline(cin,str1))
{
if(str1=="#") break;
int ans=0;
stringstream ss(str1);
while(ss>>str2)
{
if(find_(str2))
{
ans++;
insert_(str2);
}
}
cout<<ans<<endl;
for(int i=0;i<tot;i++)
{
flagg[i]=false;
for(int j=0;j<30;j++)
tree[i][j]=0;
}
tot=0;
}
return 0;
}
POJ2001
题意就是求一个能代表这个字符串的最短前缀,也就是只有这个字符串具有的前缀。
做法很显然,我们先构建好Trie树,然后对每个单词进行find,递归到直到节点出现次数为1,表示这个节点只有这一个单词走过,返回就ok。这里我用了string不断拼接字符,然后直接返回,减少了一些代码量。
POJ2001代码
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30];
int sum[maxn];
int tot;
void insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
sum[tree[root][id]]++;
root=tree[root][id];
}
}
string find_(char *str)
{
int len=strlen(str);
int root=0;
string ans="";
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
root=tree[root][id];
ans+=str[i];
if(sum[root]==1) return ans;
}
}
char ss[1005][25];
int main()
{
int tot=0;
while(scanf("%s",ss[tot++])!=EOF)
{
insert_(ss[tot-1]);
}
for(int i=0;i<tot;i++)
{
printf("%s %s\n",ss[i],find_(ss[i]).c_str());
}
return 0;
}
POJ3630
本题题意就是给你一个字符串集合,问你否所有的字符串都不是其他人的前缀。
首先我们构造出Trie树,然后对每个字符串find,当find的路径上如果出现其他字符串结尾标记,就说明其他字符串是当前字符串的前缀。注意这里对每个字符串find的时候只要搜索到 l e n − 1 len-1 len−1即可,如果搜索到 l e n len len,那么将会将本身的字符串统计进去。
POJ3630代码
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][15];
bool flagg[maxn];
int tot;
void insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'0';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
flagg[root]=true;
}
int find_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len-1;i++)
{
int id=str[i]-'0';
root=tree[root][id];
if(flagg[root]) return true;//路径上出现过其他字符串的结尾标记
}
return false;
}
char ss[10005][12];
int main()
{
int n,t;
scanf("%d",&t);
while(t--)
{
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%s",ss[i]);
insert_(ss[i]);
}
int flag=0;
for(int i=0;i<n;i++)
{
if(find_(ss[i]))
{
flag=1;
break;
}
}
if(flag==0)
printf("YES\n");
else
printf("NO\n");
for(int i=0;i<=tot;i++)
{
flagg[i]=false;
for(int j=0;j<10;j++)
tree[i][j]=0;
}
tot=0;
}
return 0;
}
LightOJ1224
本题题意是让你找出一个字符串,使该字符串作为前缀的次数 ∗ * ∗该字符串的长度结果最大
我们首先构建好trie树,我们利用记录节点出现次数的方式存储,这时候结果就是 s u m [ r o o t ] ∗ 当 前 的 l e n sum[root]*当前的len sum[root]∗当前的len,对于当前的len也就是递归深度,如果我们要存入所有节点之后再重新扫一遍Trie树复杂度会高很多,所以我们可以在插入字符串的时候进行统计,用一个maxx保存 s u m [ r o o t ] ∗ 当 前 l e n sum[root]*当前len sum[root]∗当前len的最大值就好了.具体实现看代码。
LightOJ1224代码
#include
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][5];//只有四种字符
int sum[maxn];
int tot;
int ans;
map<char,int> mm;//字符映射
void insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=mm[str[i]];
if(!tree[root][id]) tree[root][id]=++tot;
sum[tree[root][id]]++;
ans=max(ans,sum[tree[root][id]]*(i+1));//插入时直接统计结果
root=tree[root][id];
}
}
char ss[55];
int main()
{
mm['A']=0;
mm['C']=1;
mm['G']=2;
mm['T']=3;
int t,n;
scanf("%d",&t);
int cnt=1;
while(t--)
{
ans=0;
scanf("%d",&n);
while(n--)
{
scanf("%s",ss);
insert_(ss);
}
for(int i=0;i<=tot;i++)
{
sum[i]=0;
for(int j=0;j<4;j++)
tree[i][j]=0;
}
tot=0;
printf("Case %d: %d\n",cnt++,ans);
}
return 0;
}
POJ2513
本题题意是给一堆木棒,每种木棒左右两端有两种颜色,木棒进行拼接的时候,只有相同颜色之间才可以拼接,问最后是否可以将所有木棒拼为一根木棒。
我们考虑把同一种颜色的点聚在一起,我们就可以得到一个无向图,如果这个无向图是欧拉图,代表展开之后可以一笔走完,也就是可以连接成一条木棒。所以我们用trie树判断每种颜色出现的次数,再用并查集判一下图是否连通,最后用欧拉图的性质判断一下是否为欧拉图就好了(只存在两个或者0个奇度的点)
POJ2513代码
#include
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30];
int sum[maxn];
int rank_[maxn];
int f[maxn];
int vis[maxn];
int flag,flag2;
int tot;
int cnt;
int pos1,pos2;
int insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
if(!vis[root]) vis[root]=++cnt;
if(f[cnt]==0) f[cnt]=cnt;//在这里重置f数组,节省一部分时间
return vis[root];
}
int find_(int x){ return f[x]==x?x:f[x]=find_(f[x]);}
void union_(int x,int y)
{
x=find_(x),y=find_(y);
if(x!=y)
{
if(rank_[x]>rank_[y])
{
f[y]=x;
}
else
{
f[x]=y;
if(rank_[x]==rank_[y]) rank_[x]++;
}
}
}
char str1[12],str2[12];
int main()
{
while(scanf("%s%s",str1,str2)!=EOF)
{
pos1=insert_(str1);//统计该颜色对应的下标
sum[pos1]++;
pos2=insert_(str2);
sum[pos2]++;//统计每种颜色的度
union_(pos1,pos2);
}
for(int i=1;i<=cnt;i++)
{
if(sum[i]%2==1)
{
flag++;
}
if(find_(i)!=find_(1))
{
printf("Impossible\n");//非连通图
return 0;
}
}
if(flag==0||flag==2) printf("Possible\n");//欧拉图判定
else printf("Impossible\n");
return 0;
}
POJ1451
本题题意比较有意思,大概就是模拟手机输入法,先给你一个用户的词库,即每个单词出现的次数,这个时候再按照九键输入法给你一个数字序列,问你在输入这个序列的过程中,出现的字符串顺序,也就是对于每个数字序列,给出一个最有可能出现的字符串。
这道题我的做法比较巧妙,但是不怎么会算复杂度,还是很快的过去了。首先我们考虑,对于每个数字序列,我们都可以用一个string去映射,这样我们可以用一个map来离线保存每个数字序列对应的最有可能出现的字符串,可是我们怎么知道每个数字序列最有可能出现的字符串是哪个呢,首先我们对单词进行映射,把每个单词映射成数字序列,然后在插入的过程中,对于每一个前缀都更新一下这个前缀对应的map,最后查询的时候就可以直接输出了。
POJ1451代码
#include
#include
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30];
int sum[maxn];
int tot;
int belong[30];
map<string,int> mm;//每种数字序列最大出现次数
map<string,string>mm2;//每种序列对应的最大次数的字符串
void insert_(char *str,int num)
{
int len=strlen(str);
int root=0;
string strr="";
string str2="";
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
strr+=(belong[id]+'0');//将插入的字符串映射成数字序列
str2+=str[i];//当前前缀
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
sum[root]+=num;//统计每个前缀出现次数
if(mm[strr]<sum[root])//更新map
{
mm[strr]=sum[root];
mm2[strr]=str2;
}
}
return ;
}
char ss[maxn];
void init()//数字与字母间的映射
{
for(int i=0;i<25;i++)
{
if(i<18)
belong[i]=2+i/3;
else
belong[i]=2+(i-1)/3;
}
belong[25]=9;
return ;
}
int main()
{
init();
int cnt=1;
int n,m,t,num;
scanf("%d",&t);
while(t--)
{
mm.clear();
mm2.clear();
scanf("%d",&n);
while(n--)
{
scanf("%s%d",ss,&num);
insert_(ss,num);
}
scanf("%d",&m);
printf("Scenario #%d:\n",cnt++);
while(m--)
{
scanf("%s",ss);
string tmp="";
int len=strlen(ss);
for(int i=0;i<len-1;i++)
{
tmp+=ss[i];//对于每个前缀直接输出
if(!mm2.count(tmp)) printf("MANUALLY\n");
else printf("%s\n",mm2[tmp].c_str());
}
printf("\n");
}
for(int i=0;i<tot;i++)
{
sum[i]=0;
for(int j=0;j<30;j++)
tree[i][j]=0;
}
printf("\n");
}
return 0;
}
POJ1816
本题的题意是给你n个模式串和m个匹配串,模式串中有 ? 和 ∗ ?和* ?和∗两种字符,?可以匹配任意一种字符, ∗ * ∗可以匹配任意个字符,问每种匹配串可以和之前哪些模式串匹配。
我们先构建好字典树,对于每个匹配串实现find,find的时候用类似dfs的写法,如果当前节点的字符或者?存在,直接dfs下一个位置的字符,如果当前字符对应的位置有 ∗ * ∗存在,那么就从匹配串之后的每一个位置进行往下dfs,因为可以匹配任意个字符。而dfs计数的条件是匹配串匹配结束而且达到模式串某个结尾标记。则在这个模式串上做标记。需要注意的细节是此时不能直接return,因为有可能此时的字符串和剩下的匹配串还能匹配,类似模式串A : AA** 模式串B: AA*** 匹配串为AAA ,那么匹配到A字符串之后则不能停止,要继续往下搜索。
POJ1816代码
#include
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30];
bool flag[maxn];
bool vis[maxn];
int tot;
int insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id;
if(str[i]=='*') id=26;//*号存在第26位
else if(str[i]=='?') id=27;//?存在第27位
else id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
flag[root]=true;//结尾符标记
return root;
}
void find_(char *str,int pos1,int pos2)//pos1 模式串下标 pos2 匹配串下标
{
int len=strlen(str);
if(pos2==len&&flag[pos1])//达到条件则对该字符串进行标记
{
vis[pos1]=1;//对该单词的下标进行标记
}
int root=pos1;
int id=str[pos2]-'a';
if(tree[root][id])//存在相同字符
{
int tmp=tree[root][id];
find_(str,tmp,pos2+1);
}
if(tree[root][27])//存在?
{
int tmp=tree[root][27];
find_(str,tmp,pos2+1);
}
if(tree[root][26])//存在*
{
int tmp=tree[root][26];
for(int j=pos2;j<=len;j++)//对之后的每一个位置进行dfs,要注意从pos2开始,因为*号可以不匹配
find_(str,tmp,j);
}
return ;
}
char ss[maxn];
int pos[maxn];
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
{
scanf("%s",ss);
pos[i]=insert_(ss);//插入时顺带获取下标
}
while(m--)
{
int flag=0;
scanf("%s",ss);
find_(ss,0,0);
for(int i=0;i<n;i++)
{
if(vis[pos[i]])
{
flag=1;
printf("%d ",i);
}
}
for(int i=0;i<n;i++)
{
if(vis[pos[i]])
{
vis[pos[i]]=0;
}
}
if(flag==0) printf("Not match");
printf("\n");
}
return 0;
}
HDU1247
本题题意是问你某个单词是否可以拆成单词表中的其他两个单词。
我们可以建两颗Trie树,然后分别正序倒序插入每个单词,对每个单词查询的时候,我们分别正序倒序查询,对出现过单词的前缀下标进行标记,对每个出现过单词的后缀进行标记,最后扫描标记数组,如果某个位置前缀后缀均被标记过,则表示可以拆成单词表中的两个其他单词。
HDU1247代码
#include
#include
#include
#include
#include
using namespace std;
const int maxn =2e6+5;
int tree[maxn][30],tree2[maxn][30];
set<string> s;
bool flagg[maxn],flagg2[maxn];
int sum[55];
int tot,tot2;
void insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
flagg[root]=true;
return ;
}
void find_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len-1;i++)
{
int id=str[i]-'a';
root=tree[root][id];
if(flagg[root]) sum[i]++;//当前前缀是其他单词
}
return ;
}
void insert2_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree2[root][id]) tree2[root][id]=++tot2;
root=tree2[root][id];
}
flagg2[root]=true;
return ;
}
void find2_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len-1;i++)
{
int id=str[i]-'a';
root=tree2[root][id];
if(flagg2[root])
{
sum[len-i-2]++;//当前前缀是其他单词,对反转后的位置进行标记
}
}
return ;
}
char ss[50005][55];
int main()
{
int cnt=0;
while(scanf("%s",ss[cnt++])!=EOF)
{
insert_(ss[cnt-1]);//正序插入到第一棵树
strrev(ss[cnt-1]);
insert2_(ss[cnt-1]);//倒叙插入第二颗树
strrev(ss[cnt-1]);
}
for(int i=0;i<cnt;i++)
{
int len=strlen(ss[i]);
for(int j=0;j<len;j++)
{
sum[j]=0;
}
find_(ss[i]);//在第一棵树上查询并标记
strrev(ss[i]);
find2_(ss[i]);//在第二颗树上查询并标记
strrev(ss[i]);
for(int j=0;j<len;j++)
{
if(sum[j]==2)//两次查询均标记过的位置
{
string tmp=ss[i];
s.insert(tmp);
break;
}
}
}
set<string>::iterator it;
for(it=s.begin();it!=s.end();++it)
{
printf("%s\n",(*it).c_str());
}
return 0;
}
POJ2408
本题题意是,把可以通过重新排列变成相同单词的单词放入一个集合,最后按照集合元素由多到少输出前五个集合,如果集合元素相同,按照字典序由小到大输出
我们考虑,如果两个单词可以通过重新排列组合变成相同单词,那么他们的字典序最小的排列方式一定是相同的,所以我们可以利用每个元素的最小排列方式判定是否在同一个集合,字典树在这里用于判定某个字符串时候出现过。最后用set来保存以便维持字典序
POJ2408代码
#include
#include
#include
#include
#include
#include
using namespace std;
const int maxn = 1e6+5;
int tree[maxn][30];
char ss[maxn];
int tot,anstot;
int num[30];
int vis[maxn];
struct data
{
int num;
set<string> s;
}cnt[maxn];
bool cmp(const data &a,const data &b)
{
if(a.num==b.num)
{
return *(a.s.begin())<*(b.s.begin());
}
return a.num>b.num;
}
void insert_(char *str)
{
int root=0;
int len= strlen(str);
string str2="";
for(int i=0;i<len;i++)
{
num[str[i]-'a']++;
}
for(int i=0;i<26;i++)//在此转换为字典序最小的字符串
{
while(num[i]!=0)
{
str2+=(i+'a');
num[i]--;
}
}
for(int i=0;i<len;i++)
{
int id=str2[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
if(!vis[root]) vis[root]=++anstot;//若未出现过,赋予编号
cnt[vis[root]].num++;//将此字符串所在的结构体num变量+1
string tmp=str;
cnt[vis[root]].s.insert(tmp);
return ;
}
int main()
{
while(scanf("%s",ss)!=EOF)
{
insert_(ss);
}
sort(cnt+1,cnt+1+anstot,cmp);
for(int i=1;i<=5;i++)
{
printf("Group of size %d: ",cnt[i].num);
set<string>::iterator it;
for(it=cnt[i].s.begin();it!=cnt[i].s.end();++it)
{
printf("%s ",(*it).c_str());
}
printf(".\n");
}
return 0;
}
HDU1075
本题的题意是给你火星文与地球文的映射方式,然后给你一个火星文组成的文本,若某单词在映射文本中出现过,则输出映射之后的文本。否则输出原文本。
我们可以建立trie树,插入火星文本,将返回的下标pos与地球文相对应,在翻译文本的时候,从前往后截取每一段单词,在trie树上查找该单词是否出过,要注意必须是单词,而不能是某单词的前缀。若找到则返回下标,然后输出该下标对应的地球文,否则返回-1,输出原文本。
HDU1075代码
#include
#include
#include
#include
using namespace std;
const int maxn = 2e6+5;
int tree[maxn][30];
int flagg[maxn];
int pos[maxn];
int tot,tot2;
int insert_(char *str)
{
int len=strlen(str);
int root=0;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
}
flagg[root]=true;
return root;//返回下标,对应的是一个单词
}
int find_(char *str)
{
int root=0;
int len=strlen(str);
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(!tree[root][id]) return -1;
root=tree[root][id];
}
if(flagg[root]) return root;//若为完整相匹配单词,返回下标
else return -1;
}
char ss1[maxn][12];
char tmp[maxn];
int main()
{
int cnt=0;
scanf("%s",tmp);
while(scanf("%s",ss1[cnt])!=EOF)
{
if(ss1[cnt][0]=='E')
{
scanf("%s",tmp);
break;
}
scanf("%s",tmp);
pos[insert_(tmp)]=cnt;//将返回的下标与地球文进行匹配
cnt++;
}
getchar();
while(gets(tmp)!=NULL)
{
if(tmp[0]=='E') break;
int len=strlen(tmp);
char str[12];
int cnt;
for(int i=0;i<len;i++)
{
if(tmp[i]>='a'&&tmp[i]<='z'&&i<len)
{
cnt=0;
while(tmp[i]>='a'&&tmp[i]<='z')
{
str[cnt++]=tmp[i++];
}
str[cnt]='\0';//截取单词,存在str中
int pp=find_(str);
if(pp!=-1)
printf("%s",ss1[pos[find_(str)]]);//输出对应的地球文
else
printf("%s",str);
printf("%c",tmp[i]);
}
else
printf("%c",tmp[i]);
}
printf("\n");
}
return 0;
}
Lightoj1269
本题的题意是求出一段连续的区间,使这段区间异或和最小/最大。分别输出最大异或值和最小异或值。
区间异或和的题目一般都要用到前缀异或和,我们这里可以预处理出前缀异或和,然后我们考虑,对于每个值,在字典树上查找之前出现过的最优的匹配,利用字典树的特点,将其拆为二进制,贪心的去查找,查找最大值则是0找1,1找0,查找最小值则是1找1,0找0。维护一下最大值与最小值即可。Find的时候可以利用两个不同的root并行查找最大值与最小值,减少代码量。
Lightoj1269代码
#include
#include
#include
using namespace std;
const int maxn =3e6+5;
int tree[maxn][2];
int tot;
int ans,ans2;
int flagg[maxn];
void insert_(int num)
{
int root=0;
int pos=30;
int id;
while(pos!=-1)
{
if(num&(1<<pos)) id=1;
else id=0;
if(!tree[root][id]) tree[root][id]=++tot;
root=tree[root][id];
pos--;
}
return ;
}
void find_(int num)
{
int root=0;
int root2=0;
int pos=30;
int id;
ans=0;
ans2=0;
while(pos!=-1)
{
if(num&(1<<pos)) id=1;
else id=0;
if(tree[root][id^1])//最大值优先找相反的0-1,1-0
{
ans^=(1<<pos);
root=tree[root][id^1];
}
else
{
root=tree[root][id];
}
if(tree[root2][id])//最小值优先找相同的0-0,1-1
{
root2=tree[root2][id];
}
else
{
ans2^=(1<<pos);
root2=tree[root2][id^1];
}
pos--;
}
}
int a[maxn];
int sum[maxn];
int main()
{
int n,t;
int cnt=1;
scanf("%d",&t);
while(t--)
{
tot=0;
int maxx=0;
int minn=0x3f3f3f3f;
scanf("%d",&n);
insert_(0);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
sum[i]=a[i]^sum[i-1];
find_(sum[i]);//先查找
minn=min(ans2,minn);
maxx=max(ans,maxx);
insert_(sum[i]);//后插入,避免本身造成影响
}
printf("Case %d: %d %d\n",cnt++,maxx,minn);
for(int i=0;i<=tot;i++)
{
tree[i][0]=0;
tree[i][1]=0;
}
}
return 0;
}
UVA-10887
本题题意就是给你AB两个字符串集,问你以A中字符串作为前缀,B中字符串作为后缀,可以得到多少个不同的字符串,就对每个拼接后的字符串放进字典树,统计单词个数就可以了
#include
#include
#include
#include
using namespace std;
const int maxn = 2e6+5;
int root,cnt;
int ans;
int tree[maxn][26];
int end_[maxn];
int newnode()
{
end_[cnt]=0;
for(int i=0;i<26;i++)
tree[cnt][i]=-1;
return cnt++;
}
void init()
{
ans=0;
cnt=0;
root=newnode();
}
void insert_(string str)
{
int tmp=root;
int len=str.size();
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(tree[tmp][id]==-1)
{
tree[tmp][id]=newnode();
}
tmp=tree[tmp][id];
}
if(end_[tmp]==0)
{
end_[tmp]=1;
ans++;
}
return ;
}
string str1[1505];
string str2[1505];
string str3;
char tmp1[15];
char tmp2[15];
int main()
{
int n,m,t;
int cnt=1;
scanf("%d",&t);
while(t--)
{
init();
scanf("%d%d",&n,&m);
getchar();
for(int i=0;i<n;i++)
{
gets(tmp1);//读入可能有空行,用gets
str1[i]=tmp1;
}
for(int i=0;i<m;i++)
{
gets(tmp2);
str2[i]=tmp2;
}
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
str3=str1[i]+str2[j];//拼接
insert_(str3);
}
}
printf("Case %d: %d\n",cnt++,ans);
}
return 0;
}
未完待续…