BestCoder Round #77

A题 链接http://acm.hdu.edu.cn/showproblem.php?pid=5650

官方题解：我们考虑集合中的每个数x对答案的贡献。 设集合有n个数，则包含x的子集个数有2^(n-1)个。 那么当n > 1时，x出现了偶数次，所以其对答案的贡献就是0；当 n = 1时，其对答案的贡献是 x。

我的思考：当时想的时候题目看错以为是集合中所有元素相加之后再异或，导致用了队列，dfs，WA了n次，真是菜

#include<cstdio>
#include<cstring>
using namespace std;
int n,ans,a[1005];
void dfs(int num,int now)
{
ans^=num;
for(int i=now+1;i<=n;i++)
dfs(num^a[i],i+1);
}
int main()
{
int T,n,ans;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
if(n==1)
{
scanf("%d",&ans);
printf("%d\n",ans);
continue;
}
ans=0;
for(int i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
for(int i=1;i<=n;i++)
dfs(a[i],i);
printf("%d\n",ans);
}
return 0;
}

B题 链接http://acm.hdu.edu.cn/showproblem.php?pid=5651

官方题解：首先，如果不止一个字符出现的次数为奇数，则结果为0。 否则，我们把每个字符出现次数除2，也就是考虑一半的情况。 那么结果就是这个可重复集合的排列数了。 设该集合有n个数，第i个数出现次数为ai，那么结果就是 fact(n)/fact(a_1)/fact(a_2)/..../fact(a_n)fact(n)/fact(a​1​​)/fact(a​2​​)/..../fact(a​n​​)。

我的思考：通过这题学会了逆元的作用，以前只是知道这个但没去了解，原来乘法是满足同余但是除法是不满足的，需要乘以乘法逆元来代替除法，x/y%z=x*y^(z-2)%z

还有一个方法是排列组合的递推来做，高中没怎么学排列组合，所以不怎么会 C(N,M)=C(N-1,M-1)+C(N-1,M)

#include<cstdio>
#include<cstring>
#define LL __int64
using namespace std;
const int MOD=1e9+7;
LL quickmod(LL a,LL b)
{
LL temp=1;
while(b>0)
{
if(b%2==1)
temp=temp*a%MOD;
b/=2;
a=a*a%MOD;
}
return temp%MOD;
}
int main()
{
int T,cnt1,i,len;
LL ans,sum,dp[1005];
char s[1005];
int f[30];
scanf("%d",&T);
dp[1]=1;
dp[0]=1;
for(i=2;i<=1000;i++)
dp[i]=(dp[i-1]*i)%MOD;
while(T--)
{
memset(f,0,sizeof(f));
scanf("%s",s);
len=strlen(s);
sum=0;
for(i=0;i<len;i++)
{
f[s[i]-'a'+1]++;
sum++;
}
cnt1=0;
for(i=1;i<=26;i++)
if(f[i]%2==1) cnt1++;
if(cnt1>=2)
{
printf("0\n");
continue;
}
ans=1;
sum=sum/2;
while(sum>0)
{
ans=ans*sum%MOD;
sum--;
}
for(i=1;i<=26;i++)
{
ans=ans*quickmod(dp[f[i]/2],MOD-2)%MOD;
}
printf("%I64d\n",ans);
}
return 0;
}

C题 链接http://acm.hdu.edu.cn/showproblem.php?pid=5652

官方题解：这是一个连通性的问题。你会发现如果将所有操作逆序来看的话就很容易用并查集来处理了。 首先把所有的山峰都加到图中，然后逆序处理每个操作： 对某次操作，在图中删除该位置的山峰，然后判断两个点是否联通，一旦联通就得到了结果。 这里需要对China和India分别新建一个对应的节点。

我的思考：比赛时后一直以为是dp，肯定是做的太少了，图的联通性判断应该迅速的想到并查集之类的而不是别的，还是太年轻，然后逆序处理可以优化为二分，这样数据较大的时候速度会快很多

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=505;
int p[505*505],n,m,q;
char s[maxn][maxn];
int vis[maxn][maxn];
pair<int,int>d[maxn*maxn];
int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
int fi(int x)
{
return p[x]==x?x:p[x]=fi(p[x]);
}
void uni(int p1,int q1)
{
int x=fi(p1);
int y=fi(q1);
if(x!=y)
p[x]=y;
}
int check(int t)
{
for(int i=0;i<=n*m+1;i++) p[i]=i;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(s[i][j]=='1') vis[i][j]=1;
else vis[i][j]=0;
for(int i=1;i<=t;i++)
vis[d[i].first][d[i].second]=1;
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
{
for(int k=0;k<4;k++)
{
if(vis[i][j]==1) continue;
int xx=i+dx[k];
int yy=j+dy[k];
if(yy<=0||yy>m) continue;
if(xx==0) uni((i-1)*m+j,0);
else if(xx==n+1) uni((i-1)*m+j,n*m+1);
else
{
if(vis[xx][yy]==1) continue;
uni((i-1)*m+j,(xx-1)*m+yy);
}
}
}
}
int x=fi(0);
int y=fi(n*m+1);
if(x==y) return 1;
else return 0;
}
void solve()
{
memset(vis,0,sizeof(vis));
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%s",s[i]+1);
scanf("%d",&q);
for(int i=1;i<=q;i++)
{
scanf("%d%d",&d[i].first,&d[i].second);
d[i].first++;d[i].second++;
}
if(check(q))
{
printf("-1\n");
return;
}
int l=0,r=q,ans=0;
while(l<=r)
{
int mid=(l+r)/2;
if(!check(mid)) r=mid-1,ans=mid;
else l=mid+1;
}
printf("%d\n",ans);
}
int main()
{
int T;
scanf("%d",&T);
while(T--) solve();
}

D题 链接http://acm.hdu.edu.cn/showproblem.php?pid=5653

官方题解：先不考虑将结果乘以 1e6。 设 dp[i] 为从前 i 个格子的状态可以获得的最大破坏指数。那么我们可以枚举每个炸弹，该炸弹向左延伸的距离和向又延伸的距离。 设第 i 个炸弹破坏区间为 [l, r], 则 dp[r] = dp[l - 1] * log2(r - l + 1)。答案就是 dp[n - 1]。不要忘记最后要向下取整。

我的思考：当时以为是模拟，但由于太菜，连模拟代码都没有写完，之后看了题解之后感觉很简单，但当时怎么就是想不到，枚举炸弹，然后枚举炸弹的左右范围，预处理出log来，貌似这个运算的速度比较慢

#include<cstdio>
#include<cstring>
#include<queue>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<cmath>
using namespace std;
typedef long long LL;
const int N=2e3+5;
const int INF=0x3f3f3f3f;
int o
;
double dp
,val
;
int main()
{
for(int i=1;i<=2001;i++)
val[i]=log(i)/log(2);
int T;
scanf("%d",&T);
while(T--)
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
scanf("%d",&o[i]),++o[i];
sort(o+1,o+1+m);
memset(dp,0,sizeof(dp));
int c=m>1?o[2]:n+1;
for(int i=o[1];i<c;++i)
dp[i]=val[i];
for(int i=2;i<=m;++i)
for(int j=i<m?o[i+1]-1:n;j>=o[i];--j)
for(int k=o[i-1];k<o[i];++k)
dp[j]=max(dp[j],dp[k]+val[j-k]);
printf("%d\n",(int)floor(dp
*1e6));
}
}

E题 链接http://acm.hdu.edu.cn/viewcode.php?rid=16702234

官方题解：首先将数列中所有满足条件的三元组处理出来，数量不会超过 nn 个。
设 pre[i] 为第 i 个三元组前一次出现的位置，如果在前面没有出现过则设为0,对于不合法的三元组，pre[i]设为 n。 这样对于一个查询 [L, R], 我们只不需要计算出 在这个区间内有多少个三元组的 pre 值是小于 L 的。 到这里，就可以使用可持久化线段树来计算了。

我的思考：参考了snow_smile大神的代码，这题可以比较容易看出应该用树状数组或者是线段树来计数，关键是在于要判重，这就是重点，也是对着代码看了好久。mp记录hash值为x的三元组的最后位置，nxt记录下一个完全一样的三元组的位置，建立树状数组的时候只加第一条。然后对询问按照左端点升序排列，[l,r]中三元组的个数实际上就是sum(r)-sum(l+1)毕竟要完全包括，然后因为我们之前加的时侯存在重复的时候只加了第一条，然后记录下几条的位置，所以每次都要进行更新，因为我们每次计算的都是sum(r)-sum(l+1)，而且我们排序过，所以l+1之前的如果在后面有重复的话就可以进行一次更新，这样的话既不会遗漏，也不会多更新，因为每次我们之后往后更新一条，真是学到了。。很精妙的方法。

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
#define MP(x,y) make_pair(x,y)
const int N=2e5+10;
int n,T,i,m;
int c
;               //用于记录原数的数组
int b
;               //树状数组，我们利用其来统计在某个范围内有多少个数字的前驱<l
int nxt
;             //nxt[i]表示与c[i]权值相同的下一个数的位置
int l
, r
, o
;   //用于处理询问的数组
int ans
;             //用于输出答案的数组
map< pair<int, pair<int, int> >, int>mp;
bool cmp(int x, int y)
{
return l[x] < l[y];
}
int check(int x)
{
int ret=0;
for (;x;x-=x&-x)ret+=b[x];
return ret;
}
void add(int x, int val)
{
for (;x<=n;x+=x&-x)b[x]+=val;
}
int main()
{
scanf("%d",&T);
while(T--)
{
mp.clear();
scanf("%d",&n);
for(i=1;i<=n;i++) b[i]=nxt[i]=0;
for(i=1;i<=n;i++) scanf("%d",&c[i]);
for(i=3;i<=n;i++)
{
if(c[i-2]<=c[i-1]&&c[i-1]<=c[i])
{
int x=mp[MP(c[i-2],MP(c[i-1],c[i]))];
if(x==0) add(i,1);
else nxt[x]=i;
mp[MP(c[i-2],MP(c[i-1],c[i]))]=i;
}
}
scanf("%d",&m);
for(i=1;i<=m;i++)
scanf("%d%d",&l[i],&r[i]),o[i]=i;
sort(o+1,o+m+1,cmp);
int p=1;
for(i=1;i<=m;i++)
{
int left=l[o[i]];
int right=r[o[i]];
while(p<=left+1)
{
if(nxt[p]) add(nxt[p],1);
++p;
}
if(right-left>=2) ans[o[i]]=check(right)-check(left+1);
else ans[o[i]]=0;
}
for(i=1;i<=m;i++) printf("%d\n",ans[i]);
}
return 0;
}