周六日常训练，背包dp，树形dp，简单dp以及很多数学？

队内周六日常训练，我迟到了半个小时，然后两个dalao开始疯狂过题，这比赛是很多场现场赛组合来的，大概都是铜牌、铁牌，少部分银牌题。 比较适合我们队伍的情况。

A
似乎是二分图匹配？ 简单的？ 熊神交了几发就过了。
B
题意很简单：给a , b 求x,y 满足 x+y = a 且 lcm(x,y) = b
高中数学题
哼！ 不是常说
模拟只会猜题意，贪心只能过样例。图论只会套模板，数论只会gcd
这下好了，出gcd了，你看还不是不会！

从x，y下手。我们设 gcd(x,y) = c
所以 x = i*c , y = j*c （i，j互质）
于是有：
lcm(x,y) = c*i*j = b
ic + jc = a = c*(i+j)

因为 i j 互质 i*j 的因数只有i和j 和1 和自己
所以 gcd(i+j , i*j) = gcd(i,i*j) 或者gcd(j,i*j);
假设 gcd(i,i*j)=x(x!=1)
则有：
i=ax
i*j=bx => j=(a-b)x 且可知a>b 所以 j=cx ，所以gcd(i,j)!=1 ,与题设矛盾
所以 gcd(i+j , i*j) =1 所以 gcd ( a,b ) = c

所以 i + j = a/c 且 i*j = b/c
然后就是解二元一次方程组。。。所以只需解出最小的i即可

C
给一个x 可以分成任意段：x1+x2+x3….，必须满足：
1.任何两段都不相同
2.求x1*x2*x3最大值
算了，不强行分析了，数论不是gcd，超出我的能力范围了。

D
点分治，熊神补了，先不看了

E
盒子里面有k个黑球，1个红球，谁先取出红球谁就胜利，问先手会有优势吗？
一开始没想好，以为后手会有优势，sb了一下。
k=1 一黑一红 先手既无优势也无劣势，55k
k=2 两黑一红，先手取1/3赢 即使没取到 轮到后手时 也是55k ，所以先手有优势。
k=3 三黑一红
000X
先手： 1/4 赢 3/4取不到
后手： 必须建立在先手取不到的情况： P（赢）=3/4 * 1/3 =1/4
然后55k。 所以 先手既无优势也无劣势，55k
k=4 0000X 先手取完一个之后，情况和k=3相同，所以先手肯定有优势
往后推 同理

F
貌似是个挺简单的计算几何，拆成三角形计算就可以了。 s=a*b*sinx*1/2？

G
化成二进制，然后再换成八进制，4位->1位

H
题意：一条路上有n条河，每条河有起点和终点，河里面会 随机在任何位置出现一条船，并且船的速度恒等于V，但是方向向左向右是随机的，走路的速度=1，求从A 走到B 的期望时间。
对单独一条河，过河的期望= 当船在河中心 的t(v向左)+t(v向右)，这个怎么证明呢，我只能说根据题目条件可得= =，然后我们把所有河长度加起来当成一条河就可以了。

I
下载东西，一大堆规则，其实下载的总量是固定的，总速度是固定的，除一下就是答案。

J
HDU 3236
有很多物品，每个物品有体积，价值，属性(有些必须买，有些不必须)
给两个背包(v1,v2)，跑0-1背包， 以及可以免费选任何一个物品。
求最大价值。
首先我们把物品分为必须和非必须
然后跑两遍0-1 背包，根本不需要记录我们选择了哪些物品
但必须记录我们选择完必须品之后的状态 dp[i][j] 。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<string.h>
#include<map>
#include<set>
using namespace std;
template<class T> T gcd(T a,T b){return b?gcd(b,a%b):a;}

int dp[505][55][2];
//dp[i][j]代表使用的容量是i和j的最大价值， 再开一维表示免费的机会即可
struct node{
    int v,w;
    bool operator <(const node &b)const{
        return v>b.v;
    }
};
priority_queue<node>q;
int main(){
    int V1,V2,i,j,a,b,c,k,n,ans,cas,sum,pre,sign;
    cas=1;
    while(~scanf("%d%d%d",&V1,&V2,&n)&&(V1||V2||n)){
        vector<node> G[2];
        memset(dp,-1,sizeof(dp));
        for(i=0;i<n;i++){
            scanf("%d%d%d",&a,&b,&c);   // 分别是 体积和价值，是否必须
            G[c].push_back((node){a,b});
        }
        sum=dp[0][0][0]=0;
        for(i=0;i<G[1].size();i++){
            pre=sum;
            sum+=G[1][i].w;
            for(j=V1;j>=0;j--){  // 第一个背包和第二个背包都必须扫
                for(k=V2;k>=0;k--){
                    if(dp[j][k][0]==pre) //如果没用免费机会时，最大价值=pre
                        dp[j][k][1]=sum;   //则用了免费会变成 这样
                    if(j>=G[1][i].v){
                        if(dp[j-G[1][i].v][k][1]==pre)
                            dp[j][k][1]=sum;
                        if(dp[j-G[1][i].v][k][0]==pre)
                            dp[j][k][0]=sum;
                    }
                    if(k>=G[1][i].v){
                        if(dp[j][k-G[1][i].v][1]==pre)
                            dp[j][k][1]=sum;
                        if(dp[j][k-G[1][i].v][0]==pre)
                            dp[j][k][0]=sum;
                    }
                }
            }
        }
        sign=0;
        for(i=0;i<=V1;i++)
            for(j=0;j<=V2;j++)
                for(k=0;k<=1;k++){
                    if(dp[i][j][k]!=sum)  //检测是否能把必需品装下，并且我们知道剩下的状态是怎样
                        dp[i][j][k]=-1;
                    else
                        sign=1;  //我们保存了使用i,j空间装满所有必需品的状态
                }
        if(!sign){
            printf("Case %d: -1\n\n",cas++);
            continue;
        }                                       //
        for(i=0;i<G[0].size();i++){
            for(j=V1;j>=0;j--){
                for(k=V2;k>=0;k--){
                    if(dp[j][k][0]!=-1)         //要放在最前面，避免了重复装入
                        dp[j][k][1]=max(dp[j][k][1],dp[j][k][0]+G[0][i].w);
                    // 必须满足!=-1 即:把必需品装完
                    if(j>=G[0][i].v){
                        if(dp[j-G[0][i].v][k][1]!=-1)
                            dp[j][k][1]=max(dp[j][k][1],dp[j-G[0][i].v][k][1]+G[0][i].w);
                        if(dp[j-G[0][i].v][k][0]!=-1)
                            dp[j][k][0]=max(dp[j][k][0],dp[j-G[0][i].v][k][0]+G[0][i].w);
                    }
                    if(k>=G[0][i].v){
                        if(dp[j][k-G[0][i].v][1]!=-1)
                            dp[j][k][1]=max(dp[j][k][1],dp[j][k-G[0][i].v][1]+G[0][i].w);
                        if(dp[j][k-G[0][i].v][0]!=-1)
                            dp[j][k][0]=max(dp[j][k][0],dp[j][k-G[0][i].v][0]+G[0][i].w);
                    }
                }
            }
        }
        ans=0;
        for(i=0;i<=V1;i++)
            for(j=0;j<=V2;j++)
                for(k=0;k<=1;k++)
                    ans=max(ans,dp[i][j][k]);
        printf("Case %d: %d\n\n",cas++,ans);
    }
    return 0;
}

K
树形dp， 我觉得自己写的没错，但是hdu上就是只写输入都会Tle，根本不知道怎么回事，只能贴一下自己代码了
我的做法：
dfs 回溯，在记录深度，根据深度来选择符合条件的最大或最小值。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<string.h>
#include<map>
#include<set>
using namespace std;
#define ll __int64
#define N 500002
struct Edge{
    int to,di;
    int next;
};
Edge edge[N*2];
int head[N],tot;
void addedge(int u,int v,int d){
    edge[tot].to=v;
    edge[tot].di=d;
    edge[tot].next=head[u];
    head[u]=tot++;
}

int dis[N],L,R;
int deep[N],n;
int ans[N];
void dfs(int u,int pre){
    int flag=0;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int to=edge[i].to;
        int l=edge[i].di;
        if(to==pre) continue;
        flag=1;
        deep[to]=deep[u]+1;
        if(dis[u]>R)
            dis[to]=R+1;
        else
            dis[to]=dis[u]+l;
        dfs(to,u);
    }
    if(!flag) //叶子
        if(L<=dis[u] && dis[u]<=R)
            ans[u]=dis[u];

    if(ans[u]!=-1){
        if(ans[pre]==-1 )
            ans[pre]=ans[u];
        else{
            if(deep[pre]&1)
                ans[pre]=max(ans[pre],ans[u]);
            else
                ans[pre]=min(ans[pre],ans[u]);
        }
    }

}
void init(int n){
    memset(dis,0,sizeof(dis));
    memset(ans,-1,sizeof(ans));
    memset(head,-1,sizeof(head));
    deep[0]=1;
    dis[0]=tot=0;   //所以deep奇数选最大，偶数选最小
}
int main()
{
    //freopen("1.txt","r",stdin);
    while(~scanf("%d %d %d",&n,&L,&R)){
        init(n);
        int a,b,c;
        for(int i=1;i<n;i++){
            scanf("%d %d %d",&a,&b,&c);
            addedge(a,b,c);
            addedge(b,a,c);
        }
        dfs(0,0);
        if(ans[0]==-1) printf("Oh, my god!\n");
        else
            printf("%d\n",ans[0]);
    }

    return 0;
}

M
简单dp 都不会也是醉了
只需要想到，对于全排列从 x 到 x+1 长度增加1 对E的影响 要么就不变，要么就+1
于是很简单就可以写出dp方程。。。

N简单的最短路，十个点，任何算法都能过。