Codeforces Round #429 (Div. 2) D E两题总结

前三道题太水了，直接开后面两道吧。
D题题意:n个点m条边，每个点有一个值，该值等于0,1或-1,如果值为0，它的度数需要是偶数或者0，如果值为1，度数则需要为奇数，若为-1则随意。给出他们的边，需要你从中选几条边来满足所有的点的要求。

思路:试想，如果所有边都不选，那么值等于1的会不满足题意，这时候我们就要加一条边给它，我们用dfs来维护这个过程，对于结点u，它的孩子v如果d值为1，那么他们两之间的边选取状态取反，这个时候将孩子的d值变成0，代表满足题意，而父亲u结点的d值如果不等于-1，则也需要取反。可以发现，对于每个点，都能通过改变其和其父节点之间边的选取状态而改变其满足题意的状态，只有根节点没有父节点而例外，因此dfs完成后，如果根节点的状态为d[root] == 1，那么我们就要再选取一个d[i] == -1的结点i，将其到父节点的路径上所有边的选取状态取反，这样只会改变i和root结点的度数，路径上其他结点的度数并不受影响(因此满足题意的状态也不会改变)，而对i来说度数改变是无所谓的，因此这样就只将d[root]变成了0。
所以当没有d[i]==-1且d[root]==1的时候输出-1.
代码如下：

#include<iostream>
#include<vector>
using namespace std;
#pragma warning (disable:4996)
const int maxn = 300005;
typedef pair<int, int> P;
vector<P>V[maxn];
bool vis[maxn];
int d[maxn];
P fa[maxn];
int select[maxn];
void dfs(int u)
{
    int Size = V[u].size();
    for (int i = 0;i < Size;i++)
    {
        P a = V[u][i];
        if (vis[a.first])continue;
        vis[a.first] = 1;
        fa[a.first] = make_pair(u, a.second);
        dfs(a.first);
        if (d[a.first]==1)
        {
            select[a.second] ^= 1;
            d[a.first] = 0;
            if (d[u] != -1)d[u] ^= 1;

        }
    }
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1;i <= n;i++)
        scanf("%d", &d[i]);
    int u, v;
    for (int i = 1;i <= m;i++)
    {
        scanf("%d%d", &u, &v);
        V[u].push_back(make_pair(v, i));
        V[v].push_back(make_pair(u, i));
    }
    vis[1] = 1;
    dfs(1);

    if (d[1] == 1)
    {
        bool flag = false;
        int i;
        for (i = 2;i <= n;i++)if (d[i] == -1)
        {
            flag = true;
            break;
        }
        if (flag == false) { puts("-1");return 0; }
        else
        {
            while (i!=1)
            {
                select[fa[i].second] ^= 1;
                i = fa[i].first;
            }
        }
    }
    int ans = 0;
    for (int i = 1;i <= m;i++)
        if (select[i])
            ans++;
    cout << ans << endl;
    for (int i = 1;i <= m;i++)
        if (select[i])
            printf("%d\n", i);
    return 0;
}

E题题意:题意很简单，给你n个数，询问你有几种排列方式，可以使相邻的数相乘不是平方数，注意即使给你相同的数，比如给你2个1，这两个1也算是不同的数字。
这其实算是一道原题，和HDU6116差不多，但是需要转换一下。
首先我们将这些数分成k组，如果相乘为平方数的就为同一组。那么就转换成和hdu6116一样的题了，即有t组数，同组数不能排在一起，问一共有几种排列方式。
做法为dp。
我们设dp[i][j]为已经放了i组数，他们的排列中有j个缝隙，缝隙左右两边的数是同一组的。
那么答案就是dp[t][0]。
问题来了，状态转移怎么写呢？
假设我们在放第i组时，前i-1组的排列中有j个缝隙左右两边的数是同一组的。则前面的答案为dp[i-1][j]，这时我们将第i组数分成k+1份（其中有1份为单独1个数），那么第i组中有cnti-1-k个缝隙两边数是同一组的，将这k+1份放进之前i-1组数组成的排列中m个缝隙(注意这些缝隙左右两边都为相同的数)里，新产生的不符合题意的缝隙则为j+cnt[i]-1-k-m.
则转移方程式可写为
dp[i][j+cnt[i]-1-k-m]=dp[i][j+cnt[i]-1-k-m]+dp[i-1][j]* C(cnt[i]-1,k) *C(j,m) *C(lim-1-j+2,k+1-m)(lim为前i-1组数总个数)。
那么后面三个组合数是什么意思呢，留给读者思考。
代码如下:

#include<iostream>
#include<algorithm>
using namespace std;
#pragma warning (disable:4996)
const int maxn = 305;
const int mod = 1000000007;
typedef long long LL;
int a[maxn];
int tot;
int Array[maxn];
bool vis[maxn];

bool check(LL a)
{
    LL l = 1, r = 1e9;
    LL mid;
    while (l <= r)
    {
        mid = (l + r) >> 1;
        if (mid*mid >= a)
            r = mid - 1;
        else
            l = mid + 1;
    }
    return l*l == a;
}
LL C[maxn][maxn];
LL fact[maxn];

void init()
{
    C[0][0] = 1;
    C[1][0] = 1;
    C[1][1] = 1;
    for (int i = 2;i <= 300;i++)
        C[i][0] = 1;
    for(int i=2;i<=300;i++)
        for (int j = 1;j <= i;j++)
        {
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
        }
    fact[0] = 1;
    for (int i = 1;i <= 300;i++)
        fact[i] = fact[i - 1] * i%mod;
}
int dp[maxn][maxn];

void solve()
{
    int cnt = Array[0];
    dp[0][cnt - 1] = 1;
    for (int i = 1;i < tot;i++)
    {
        for (int j = 0;j < cnt;j++)
        {
            for (int k = 0;k < Array[i];k++)
            {
                for (int m = 0;m <= min(j, k + 1);m++)
                {
                    dp[i][j + Array[i] - 1 - k - m] = (dp[i][j + Array[i] - 1 - k - m] + 1LL*dp[i - 1][j] * C[Array[i] - 1][k]%mod * C[j][m]%mod * C[cnt - 1 - j + 2][k + 1 - m]%mod)%mod;
                }
            }
        }
        cnt += Array[i];
    }
    LL ans = dp[tot-1][0];
    //cout << ans << endl;
    for (int i = 0;i < tot;i++)
    {
        ans = ans*fact[Array[i]];
        ans %= mod;
    }
    cout << ans << endl;
}


int main()
{
    int n;
    cin >> n;
    for (int i = 1;i <= n;i++)
    {
        scanf("%d", &a[i]);
    }

    for (int i = 1;i <= n;i++)if (!vis[i])
    {
        for (int j = i;j <= n;j++)
        {
            if (check(1LL * a[i] * a[j]))
            {
                vis[j] = 1;
                Array[tot]++;
            }
        }
        tot++;
    }
    //cout << tot << endl;
    init();
    solve();

}

按照上面的思路可以顺利的解决E题，但是真正的问题来了，读者可以试试按照上述思路写一下hdu6116，不出意外的肯定会超时或者超内存，超内存好解决，换一种方式求组合数，那么如何解决超时呢？，博主和大佬们商量了一下，大佬们说了一种可优化成n^2的方法，但博主还不会(唉)，等以后会了会及时更新博客。。