1.1001-HDOJ 5763 Another Meaning
题意：有两个字符串A和B，字符串A中包含字符串B，字符串B有两层含义，问A串有几种含义？
题解：因为凡是字符串A包含字符串B的位置,均会有两种含义，所以我们可以先用KMP求解出字符串A中包含B的位置，标记这些位置。
然后令dp[i]表示,字符串A前i个字符构成的串的含义数那么考虑两种转移:
末尾不替换含义：dp[i - 1]
末尾替换含义：dp[i - |B|] (A.substr(i - |B| + 1,|B|) = B)
所以如果当前位置 可以替换则dp[i]=dp[i-1]+dp[i-|B|]，否则dp[i]=dp[i-1]。
代码：
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
const int MAX=100000+10;
const int MOD=1000000007;
int Next[MAX];
int vis[MAX];
int dp[MAX];
void buildNext(string P)
{
int m=P.size();
Next[0]=-1;
int i=0,j=-1;
while(i<m)
{
if(j<0||P[i]==P[j])
{
i++;j++;
Next[i]=P[i]!=P[j]?j:Next[j];//Next数组优化
}
else
{
j=Next[j];
}
}
}
void KMP(string T,string P)
{
buildNext(P);
int n=T.size(),i=0;//原串
int m=P.size(),j=0;//模式串
while(i<n&&j<m)
{
if(j<0||T[i]==P[j])
{
i++;j++;
}
else
{
j=Next[j];
}
if(j==m)
{
vis[i]=1;//记录匹配末位置的下一个位置
j=Next[j];
}
}
}
int main()
{
int T;
scanf("%d",&T);
getchar();
for(int tcase=1;tcase<=T;tcase++)
{
string T;
string P;
getline(cin,T);
getline(cin,P);
int n=T.size();
int m=P.size();
memset(vis,0,sizeof(vis));
KMP(T,P);
dp[0]=1;
for(int i=1;i<=n;i++)
{
dp[i]=dp[i-1];
if(vis[i])
{
dp[i]=(dp[i]+dp[i-m])%MOD;
}
}
printf("Case #%d: %d\n",tcase,dp[n]);
}
}2. 1010-HDOJ 5773 The All-purpose Zero
题意：题意很简单,给你一个序列,其中的0可以换成任意整数（包括负数）。问该序列的最长上升子序列的长度为多少？
题解：因为0可以充当任意整数，所以要尽可能多地放入最长上升子序列。
我们可以先不考虑0，先求出排除0之后的序列的最长上升子序列。最后在加上0的个数即是答案。
而且题目要保证严格递增，所以先对每个非0数减去他前面的0的个数，再求LIS，这样最后插入0之后可以保证严格递增。
之所以要减去他前面的0的个数，是因为要处理这种情况：
序列为：1，0，2，0，3，4，去掉0之后是1，2，3，4，LIS是4，但其实由于要严格递增所以我们不能再其中插入0，我们对每个数减去0的个数之后会是：1，1，1，2，LIS是2，我们加上0的总数2，相当于0总是有效的，即使没有空隙我也可以用来替代他两边的数，比如这个例子我可以取1，0，0，2，最后得出的序列为1，2，3，4，也可以取0，1，0，2，最后得出的序列可以是-1，2，3，4，也可以取0，0，1，2，最后的出的序列可以是-2，-1，3，4
代码：
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
const int MAX=100000+10;
int a[MAX];
int dp[MAX];
int main()
{
int T;
scanf("%d",&T);
for(int tcase=1;tcase<=T;tcase++)
{
int N;
scanf("%d",&N);
int zero=0;
int n=0;
for(int i=0;i<N;i++)
{
int tmp;
scanf("%d",&tmp);
if(tmp==0) zero++;
else a[n++]=tmp-zero;
}
int len=1;
dp[0]=a[0];
for(int i=1;i<n;i++)
{
int pos=lower_bound(dp,dp+len,a[i])-dp;
dp[pos]=a[i];
len=max(len,pos+1);
}
printf("Case #%d: ",tcase);
if(zero==N)//特判全为0
printf("%d\n",N);
else printf("%d\n", len+zero);
}
return 0;
}3.1012-HDOJ 5775 Bubble Sort
题意：给你一个1~n的排列,问冒泡排序过程中,数字i(1<=i<=n)所到达的最左位置与最右位置的差值的绝对值是多少？
题解：冒泡排序不停地交换相邻两个数，所以可以发现每个数都要与他后面的比他小的数交换一次，所以到达的最右边的位置应该是原位置加上右边比他小的数的个数，最左边的位置应该是原位置和最终位置的最小值。
统计右边比他小的数，用树状数组从右往左依次加入树状数组。第i个数右边比他小的数的个数为sum(a[i]).
代码:
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
const int MAX=100000+10;
int b[MAX];//BIT数组
int a[MAX];
int cnt[MAX];//右边的逆序对
int l[MAX],r[MAX];
int n;
int sum(int x)
{
int s=0;
while(x>0)
{
s+=b[x];
x-=(x&(-x));
}
return s;
}
void add(int x,int value)
{
while(x<=n)
{
b[x]+=value;
x+=(x&(-x));
}
}
int main()
{
int T;
scanf("%d",&T);
for(int tcase=1;tcase<=T;tcase++)
{
memset(b,0,sizeof(b));
memset(cnt,0,sizeof(cnt));
scanf("%d",&n);
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
for(int i=n;i>0;i--)
{
cnt[a[i]]+=sum(a[i]);
add(a[i],1);
}
printf("Case #%d:", tcase);
for(int i=1;i<=n;i++)
{
l[a[i]]=min(a[i],i);
r[a[i]]=i+cnt[a[i]];
}
for(int i=1;i<=n;i++)
{
printf(" %d", abs(r[i]-l[i]));
}
printf("\n");
}
return 0;
}4.1006-HDU 5769 Substring
题意：给一个字符串S和一个字符C，要求出包含字符C的S的不同的子串有多少个？
题解：后缀数组可以求出一个字符串的不同的子2串有多少个。个数为：
若sa[i]+height[i]的值大于c的位置，这与正常的没有区别，但是若c的位置大于sa[i]+height[i]，那么这个sa能贡献的就只有c位置和之后的串，这里取个最大值就行了。
总数就是：
后缀数组还有点不明白，先套板子做了。
代码：
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAX=100000+10;
int rk[MAX],sa[MAX],height[MAX];
//rk-名次数组，sa后缀数组，height-LCP相邻后缀的最长公共前缀长度
int s[MAX],buc[MAX],x[MAX],y[MAX];
//s-原数组，buc-计数排序数组，x，y-两个关键字数组
int nxt[MAX];
//距离i的后缀中距离i最近的位置
void getsa(int n,int m)
{
int i,k,p;
//对长度为1的子串计数排序
for(i=0; i<m; i++) buc[i]=0;
for(i=0; i<n; i++) buc[x[i]=s[i]]++;
for(i=1; i<m; i++) buc[i]+=buc[i-1];
for(i=n-1; i>=0; i--) sa[--buc[s[i]]]=i;
//开始倍增
for(k=1; k<=n; k<<=1)
{
p=0;
//对第二关键字排序
for(i=n-1; i>=n-k; i--) y[p++]=i; //后缀在原字符串中的起始位置在第n-k至n的元素的第二关键字都为0，因此如果按第二关键字排序，必然这些元素都是排在前面的
for(i=0; i<n; i++) if(sa[i]>=k) y[p++]=sa[i]-k;
for(i=0; i<m; i++) buc[i]=0;
for(i=0; i<n; i++) buc[x[y[i]]]++;
for(i=1; i<m; i++) buc[i]+=buc[i-1];
for(i=n-1; i>=0; i--) sa[--buc[x[y[i]]]]=y[i];
swap(x,y);
p=1;
x[sa[0]]=0;
for(i=1; i<n; i++)
{
if(y[sa[i]]==y[sa[i-1]]&&y[sa[i]+k]==y[sa[i-1]+k]) x[sa[i]]=p-1;
else x[sa[i]]=p++;
}
if(p>=n) break;
m=p;
}
return ;
}
void getlcp(int n)
{
int i,j,k=0;
//对rk数组求值的for语句的初始语句是i=1 而不是i=0 的原因,
//因为sa[0]总是等于那个已经失去作用的0号字符，所以没必要求出其rk值
for(i=1; i<=n; i++) rk[sa[i]]=i;
for(i=0; i<n; height[rk[i++]]=k)
for(k?k--:0,j=sa[rk[i]-1]; s[i+k]==s[j+k]; k++);
return ;
}
int main()
{
int T;
scanf("%d",&T);
for(int tcase=1; tcase<=T; tcase++)
{
char ch,str[MAX];
scanf(" %c",&ch);
scanf(" %s",str);
int len=strlen(str);
for(int i=0; i<len; i++)
s[i]=str[i]-'a'+1;
s[len]=0;
getsa(len+1,30);
getlcp(len);
nxt[len]=len;
for(int i=len-1; i>=0; i--)
nxt[i]=str[i]==ch?i:nxt[i+1];
long long ans=0;
for(int i=1; i<=len; i++)
{
ans+=len-max(nxt[sa[i]],sa[i]+height[i]);
}
printf("Case #%d: %I64d\n",tcase,ans);
}
return 0;
}
308
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
