树形dp和二分图

树形dp

没有上司的舞会

树形dp主要是用于对一棵树上的结点按照树的遍历顺序进行动态规划，树形dp的思维难度不高，主要原因是树的遍历方式一般固定，dp的变化不多，所以多做题熟悉树形dp的方式就可以很好的掌握这种算法。
没有上司的舞会.
在一场舞会上，每个员工不能和自己的直接上司共同出席，每个员工都有出席的快乐质数，求舞会最大的快乐值。
这是很经典的树形dp图，主要是用到树的遍历嵌套上01背包
状态表示：

f[u][0]：所有以u为根的子树中选择，并且不选u这个点的方案
f[u][1]：所有以u为根的子树中选择，并且选u这个点的方案

属性：求出这场舞会的最大快乐值

状态计算：
当目前u这个结点选的时候，子节点一定不能选

    f[u][1] += f[j][0];

当目前u这个结点不选的时候，子节点可以选可以不选

	f[u][0] += max(f[j][0], f[j][1]);

存点的话可以用邻接表来存，邻接表比较适合dfs

#include<bits/stdc++.h>
#define ll long long 
using namespace std;
const ll mod = 1000000007;
pair<int, int> mate[10];
const int N = 6000 ;
const int M = 200010;
typedef pair<int, int> PII;
//priority_queue<int, vector<int>, less<int> > q;  //这样就是小顶堆

int h[N], e[N], ne[N], idx;
int happy[N];
int n;
bool has_fa[N];
int f[N][2];

void add(int a,int b)
{
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

void dfs(int u)
{
    f[u][1] = happy[u];
    for (int i = h[u]; ~i;i=ne[i])
    {
        int j = e[i];
        dfs(e[i]);
        f[u][1] += f[j][0];
        f[u][0] += max(f[j][0], f[j][1]);
    }
}   

int main()
{
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n;i++)
    {
        cin >> happy[i];
    }
    
    for (int i = 0; i < n-1 ;i++)
    {
        int a,b;
        cin >> a >> b;
        add(b, a);
        has_fa[a] = true;
    }
    int root = 1;
    while(has_fa[root])
        root++;
    dfs(root);
    cout << max(f[root][1], f[root][0]);
    return 0;
}

选课

选课.
有些课会有一门先选课，如果要选这门课的话，就需要把所有的先选课都选上，每一门课都有学分，求可以选择的最大学分。
这题用到的是树上的分组背包来求解，每一门课以及它的所有儿子结点是一组，一组内需要的体积就是从根结点到这个点的点的个数，这题有一点需要注意，可能会出现多棵树，这就需要创造出一个虚拟结点0，以这个结点为根节点，把所有树变成一棵树。

状态表示

f[u][j]：所有以u为根节点，选了j个结点的方案

属性：这个方案的最大值

状态计算：
我们已经把这题按照分组背包的优化，将二维优化到一维，所以为了用到上一组的状态，我们需要从后往前遍历，不然会发生串联，具体可以看分组背包。对于每一个结点，枚举一下背包的容量，然后遍历一下要挑选的点的个数，e[i]为当前结点的子节点。

            f[u][j] = max(f[u][j], f[u][j - k]+f[e[i]][k]);

void dfs(int u)     
{
    for (int i = h[u]; i != -1;i=ne[i])物品组
    {
        dfs(e[i]) ;
        for (int j = m - 1; j;j--)背包容量
        {
        决策组内的选择，下标从1开始可以参见前面的分组背包问题
            for (int k = 1; k <= j;k++)
            {
                f[u][j] = max(f[u][j], f[u][j - k]+f[e[i]][k]);
            }
        }
    }       
	选u本身也会有价值，加上选u的价值

    for (int i = m; i;i--)
    {
        f[u][i] = f[u][i - 1] + w[u];
    }
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n;i++)
    {
        int p;
        cin >> p >> w[i];   
        add(p, i);
    }
    m++;
   	构造虚拟结点0
    dfs(0);
    cout << f[0][m];
    return 0;
}

二分图

二分图的定义

将所有点分成两个集合，使得所有边只出现在集合之间，就是二分图

二分图的性质

二分图：一定不含有奇数环，可能包含长度为偶数的环， 不一定是连通图

我们可以依据二分图的性质来操作，用染色法来判断一个图是不是二分图
首先，我们开一个color数组，用1和2来区分不同的颜色，0表示还未染色。
然后遍历所有的点，每次将未然而的点进行不断的递归，染色成1或者2
只要出现有一个点有矛盾，就说明这个图不是二分图，我们就可以直接退出递归，有矛盾是指一条边上的两个点是相同的颜色

bool dfs(int u,int c)
{
    color[u]=c;
    for(int i=h[u];~i;i=ne[i])
    {
        int j=e[i];
        if(!color[j])
        {
            if(!dfs(j,3-c))return false;
        }
        else if(color[j]==c)
        {
            return false;
        }
    }
    return true;
}

int main()
{
    memset(h,-1,sizeof h);
    scanf("%d%d",&n,&m);
    while(m--)
    {
        int a,b;
        scanf("%d%d",&a,&b);
        add(a,b);
        add(b,a);
    }
    bool flag=true;
    for(int i=1;i<=n;i++)
    {
        if(!color[i])
        {
            if(!dfs(i,1))
            {
                flag=false;
                break;
            }
        }
    }
    if(flag)
    {
        cout<<"Yes"<<endl;
    }
    else{
        cout<<"No"<<endl;

    }
    return 0;
}