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[N];
double dp[N],val[N];
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[n]*1e6));
    }
}

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

官方题解：首先将数列中所有满足条件的三元组处理出来，数量不会超过 $n$ 个。 设 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[N];               //用于记录原数的数组
int b[N];               //树状数组，我们利用其来统计在某个范围内有多少个数字的前驱<l
int nxt[N];             //nxt[i]表示与c[i]权值相同的下一个数的位置
int l[N], r[N], o[N];   //用于处理询问的数组
int ans[N];             //用于输出答案的数组
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;
}