2018 Multi-University Training Contest 4 - （B，D，J，L）

                        Problem B. Harvest of Apples（HDU6333） 

题意：给出n和m，求C(n,0)+C(n,1)+C(n,2)+...+C(n,m).

解析：设S(n,m)=C(n,0)+C(n,1)+C(n,2)+...+C(n,m)。显然S(n,m-1)=C(n,0)+C(n,1)+C(n,2)+...+C(n,m-1).

又因为C(n,m)=C(n-1,m-1)+C(n-1,m)，所以S(n,m)=[0+C(n-1,0)]+[C(n-1,0)+C(n-1,1)]+[C(n-1,1)+C(n-1,2)]+...+[C(n-1,m-1)+C(n-1,m)]=2*[C(n-1,0)+C(n-1,1)+...+C(n-1,m-1)]+C(n-1,m)=2*S(n-1,m)-C(n-1,m)。

可得：

• S(n,m+1)=S(n,m)+C(n,m+1)
• S(n,m−1)=S(n,m)−C(n,m)
• S(n+1,m)=2*S(n,m)−C(n,m)
• S(n−1,m)=(S(n,m)+C(n−1,m))/2

于是我们可以用莫队算法离线处理查询。

参考：http://cubercsl.cn/wiki/2018-HDU-4/

           http://www.cnblogs.com/xiuwenli/p/9403526.html

代码：

#include 
using namespace std;
typedef long long ll;
const int MAXN =1e5+5;
const int mod = 1e9+7;

ll fac[MAXN],inv[MAXN];
ll inv2;//2的逆元

ll pow_mod(ll n,ll k)//快速幂求n^k余m的结果
{
    ll res=1;
    n=n%mod;
    while(k>0)
    {
        if(k&1)
            res=res*n%mod;
        n=n*n%mod;
        k>>=1;
    }
    return res;
}

ll Comb(int n,int k)//求组合数
{
    return fac[n]*inv[k]%mod *inv[n-k]%mod;
}
void init()
{
    inv2=pow_mod(2,mod-2);
    fac[0]=fac[1]=1;

    for(int i=2;i=0;i--)
        inv[i]=inv[i+1]*(i+1)%mod;
}
int pos[MAXN],blockLen;
struct Query
{
    int L,R,id,block;
    Query(){}
    Query(int l, int r, int ID):L(l), R(r), id(ID){
        block = l / blockLen;
    }
    bool operator <(const Query& p) const
    {
        if(block==p.block) return RQ[i].L) delN(curL--,curR);
        while(curR>Q[i].R) delM(curL,curR--);
        ans[Q[i].id]=res;
    }
    for(int i=1;i<=T;++i)
        printf("%lld\n",ans[i]);
    return 0;
}

 

                       Problem D. Nothing is Impossible（HDU6335）

题意：有n道题，m个学生，第i个题有1个正确答案bi个错误答案，每个学生答对一道题获得1分，获得分数最高的学生获胜，但m个学生是一个团队，他们集体会按照某种策略做题，使得有人的分数尽可能大。他们是同时做完题目集体交卷之后才知道正确答案和分数，而正确答案是不确定的。他们策略就是在m的限制下选择一个题目的集合S，使得能够通过分配每个人的选项使得将这个集合的题目全部做对，而集合之外的题目是否有人做对无法保证，所以不予考虑。

解析：总体思路就是：学生选择最优的策略，但考虑的是最坏的情况，即结果是在最坏情况下的最大值。

考虑怎样选择集合S中的题目，因为不知道正确答案是哪个，想保证第一道题目1有人做对就得让b1+1个人来分别选不同选项，使得至少有一个人做对。考虑再多一道题2，那么两个题总共的选项方案数就是(b1+1)*(b2+1)，其中只有1个为正确方案，那么让(b1+1)*(b2+1)个人分别选择每个方案，就能保证有一个人正确。依次类推到|S|道题目。显然我们只要先选bi小的题目，直到m不够。

比赛时这个题目的题面一再更改，更改之前的题面我读了多遍都没有读懂实在是遇到的最难读的题，最终版的题面与初始的有较大出入，题目也直接变成了一道水题，但今天看dls直播，他们队十几分钟就理解了正确的题意，还是自己菜啊。而且根据正解可知如果ai不全是1那么对于这种解法是没有影响的，因为如果ai+bi个选项有bi个错误，那么选择bi+1个根据容斥定理，一定至少一有个正确。

题解中的解释：

如果仅有 1 道题，至少有一个人做对这题需要有 错误答案个数 + 1 个人。 那么容易发现在每道题正确答案只有一个的情况下，如果 n道题中存在 s道题，使得学生人数 m不少于每道题 错误答案个数 + 1 相乘的 结果，那么一定有人能够得到 s分。故我们将题目按错误答案个数从小到大排序，找到最大的 p满足[ ∏ i≤p（bi+1）] ≤ m就是答案。

代码：

#include 
using namespace std;
typedef long long ll;
const ll MAXN=1e2+5;

int n,m,b[MAXN];

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
            scanf("%*d%d",&b[i]);
        sort(b+1,b+1+n);
        ll sum=1;
        for(int i=1;i<=n+1;i++)
        {
            if(i==n+1||sum*(b[i]+1)>m) { printf("%d\n",i-1);break;}
            else { sum=sum*(b[i]+1);}
        }

    }
    return 0;
}

 

                          Problem J. Let Sudoku Rotate（HDU6341）

题意：有16*16的数独，包含4*4的regions，它不一定是合法的，问至少将某些region顺时针旋转共几次可得到合法的数独。

解析：dfs+剪枝即可，下面是dls的代码，31ms。

代码：

#include 
using namespace std;

char s[16][16],w[16][16];
int Ans;

void Rot(int a,int b)//顺时针旋转(a,b)为左上角的regions一次
{
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            w[j][3-i]=s[a+i][b+j];
    for(int i=0;i<4;i++)
        for(int j=0;j<4;j++)
            s[a+i][b+j]=w[i][j];
}

int tot,vis[16];

bool check(int a,int b)//检查(a,b)为左上角的regions是否合法
{
    for(int i=a;i=Ans)//最优性剪枝
        return;
    if(j==4)//该看下一行
        return dfs(i+1,0,k);
    for(int t=0;t<4;t++)//当前regions旋转t次
    {
        if(check(i*4,j*4))//可行性剪枝
            dfs(i,j+1,k+t);
        Rot(i*4,j*4);
    }
}

void solve()
{
    for(int i=0;i<16;i++)
        scanf(" %s",s[i]);
    for(int i=0;i<16;i++)
        for(int j=0;j<16;j++)
            if(s[i][j]<='9')
                s[i][j]-='0';
            else
                s[i][j]=s[i][j]-'A'+10;
    Ans=1000;dfs(0,0,0);
    cout<>t;
    while(t--)
        solve();
    return 0;
}

 

 

                        Problem L. Graph Theory Homework（HDU6343）

题意：有n个点，点i与点j之间距离是floor(sqrt(abs(wi-wj)))，求点1与点n之间最短路径。

解析：如果求i与j之间的距离，直接求答案为floor(sqrt(abs(wi-wj)))。如果想要通过一个中间值k来求i与j之间的距离，即为i与k之间距离加上k与j之间的距离。有以下两种情况：

①.当wk不在区间[min(wi,wj),max(wi,wj)]之中，那么显然用中间值只会使的距离增加。
②.假设wk在区间[min(wi,wj),max(wi,wj)]之中，那么有i与j之间的距离=floor(sqrt(abs(wk-wi)))+floor(sqrt(abs(wj-wk))),而abs(wk-wi)+abs(wj-wk)=abs(wj-wi)根据三角不等式（sqrt(a)+sqrt(b)≥sqrt(a+b)）可知这种方法也会使距离增加。

代码：

#include
using namespace std;
typedef long long ll;
int a[100010];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        printf("%lld\n",(ll)(sqrt)((abs)(a[n]-a[1])));
    }
}