贪心 dp-Codeforces-1286A-Garland

题目链接
题意：
有n个数字分别问1~n，将这n个数字排成一个序列，如果序列中数字为0，代表该位置的数字未知，否则该位置的数字确定。如果相邻的数字奇偶性相同的话，那么算为一段，求该序列可能的最小段数。
思路：
以下给出（贪心）和dp两种做法…贪心还是别看了
这道题题目中标了dp和greedy，然后我就毫不犹豫的往贪心上想…
然后得出了贪心写法（我都不知道这是什么鬼思路，我瞎写了两百行代码错了好几次才过？？但是可能时间需要的稍微少一点？？但是这道题完全不卡这些…）
这个贪心想法太麻烦了我实在写不出了…可能是我想太多了…
AC代码（我都不忍心再看一遍）：

#include 
using namespace std;
typedef long long ll;
ll a[105];
struct hh1
{
    ll pos1, pos2, cntt;
} k1[105];
bool cmp1(hh1 k1, hh1 k2)
{
    return k1.cntt < k2.cntt;
}
struct hh2
{
    ll pos1, pos2, cntt;
} k2[105];
bool cmp2(hh2 k1, hh2 k2)
{
    return k1.cntt < k2.cntt;
}
int main()
{
    ll n, m, k, i, j, z, x, num, ans, flag, sum, sum1, sum2, ans1, ans2, pos, flag1, flag2;
    scanf("%lld", &n);
    memset(a, 0, sizeof(a));
    sum = 0, sum1 = 0, sum2 = 0, ans = 0;
    ll cnt = 0;
    for (i = 1; i <= n; i++)
    {
        scanf("%lld", &a[i]);
        if (a[i] % 2 == 1)
            sum1++;
        else if (a[i] != 0)
            sum2++;
    }
    ll cnt1 = (n + 1) / 2 - sum1; //还剩的奇数个数
    ll cnt2 = n / 2 - sum2;       //还剩的偶数个数
    flag = 0, sum1 = 0, sum2 = 0;
    for (i = 1; i <= n; i++)
    {
        if (a[i] == 0)
            sum++;
        else if (a[i] % 2 == 1)
        {
            if (flag == 1)
            {
                sum1++;
                k1[sum1].cntt = sum;
                k1[sum1].pos1 = i - sum - 1;
                k1[sum1].pos2 = i;
            }
            sum = 0;
            flag = 1;
            pos = i;
        }
        else
        {
            if (flag == 2)
            {
                sum2++;
                k2[sum2].cntt = sum;
                k2[sum2].pos1 = i - sum - 1;
                k2[sum2].pos2 = i;
            }
            sum = 0;
            flag = 2;
            pos = i;
        }
    }
    if (flag == 0)
    {
        if (n == 1)
            printf("0\n");
        else
            printf("1\n");
    }
    else
    {
        sort(k1 + 1, k1 + sum1 + 1, cmp1);
        sort(k2 + 1, k2 + sum2 + 1, cmp2);
        for (i = 1; i <= sum1; i++)
        {
            if (cnt1 >= k1[i].cntt)
            {
                for (j = k1[i].pos1 + 1; j < k1[i].pos2; j++)
                    a[j] = 1;
                cnt1 = cnt1 - k1[i].cntt;
            }
        }
        for (i = 1; i <= sum2; i++)
        {
            if (cnt2 >= k2[i].cntt)
            {
                for (j = k2[i].pos1 + 1; j < k2[i].pos2; j++)
                    a[j] = 2;
                cnt2 = cnt2 - k2[i].cntt;
            }
        }
        flag = 0;
        for (i = 1; i <= n; i++)
        {
            if (a[i] != 0)
            {
                if (a[i] % 2 == 0)
                {
                    if (cnt2 < i - 1)
                    {
                        ans++;
                    }
                    else
                    {
                        cnt2 = cnt2 - i + 1;
                    }
                }
                else
                {
                    if (cnt1 < i - 1)
                    {
                        ans++;
                    }
                    else
                    {
                        cnt1 = cnt1 - i + 1;
                    }
                }
                break;
            }
        }
        for (i = n; i >= 1; i--)
        {
            if (a[i] != 0)
            {
                if (a[i] % 2 == 0)
                {
                    if (cnt2 < n - i)
                    {
                        ans++;
                    }
                    else
                    {
                        cnt2 = cnt2 - n + i;
                    }
                }
                else
                {
                    if (cnt1 < n - i)
                    {
                        ans++;
                    }
                    else
                    {
                        cnt1 = cnt1 - n + i;
                    }
                }
                break;
            }
        }
        flag1 = 0; //表示前一个非0数的奇偶..
        flag2 = 0; //表示中间有没有0
        for (i = 1; i <= n; i++)
        {
            if (a[i] == 0)
                flag2 = 1;
            else if (a[i] % 2 == 1)
            {
                if (flag1 == 1 && flag2 == 1)
                    ans += 2;
                flag1 = 1;
                flag2 = 0;
            }
            else
            {
                if (flag1 == 2 && flag2 == 1)
                    ans += 2;
                flag1 = 2;
                flag2 = 0;
            }
        }
        cnt = 0, sum1 = 0, sum2 = 0;
        for (i = 1; i <= n; i++)
        {
            if (a[i] != 0)
            {
                cnt++;
                a[cnt] = a[i];
            }
        }
        for (i = 2; i <= cnt; i++)
        {
            if ((a[i] + a[i - 1]) % 2 == 1)
                ans++;
        }
        printf("%lld\n", ans);
    }
}

然后又去看了过了的dl的代码，但是没有注释，然后我就又简化了一点并且加了注释，然后简化了以后只有20+行…比我那200行代码强太多了QAQ，好好学dp吧。
AC代码及注释如下：

#include 
using namespace std;
typedef long long ll;
#define INF 0x3f3f3f3f
ll dp[105][105][2], a[105];
//dp[i][j][0]表示这个序列的前i个数中，有j个偶数，第i-1位是偶数
//dp[i][j][1]表示这个序列的前i个数中，有j个偶数，第i-1为是奇数
//之所以让第二维为偶数个数是因为最终序列中的偶数个数比较容易表示（如果为奇数的话，其实也就最后中括号里加小括号的区别..）
int main()
{
    ll n, i, j;
    memset(dp, INF, sizeof(dp));//初始化dp的所有值，把他们变成一个比最大可能的答案要大的数
    scanf("%lld", &n);
    for (i = 1; i <= n; i++)
        scanf("%lld", &a[i]);
    dp[0][0][0] = 0, dp[0][0][1] = 0;//
    for (i = 1; i <= n; i++)
    {
        for (j = 0; j <= i; j++)
        {
            if (a[i] % 2 == 1 || a[i] == 0)
                dp[i][j][1] = min(dp[i - 1][j][0] + 1, dp[i - 1][j][1]);//转移方程参照dp数组的注释理解
            if (a[i] % 2 == 0 && j >= 1)
                dp[i][j][0] = min(dp[i - 1][j - 1][0], dp[i - 1][j - 1][1] + 1);
        }
    }
    printf("%lld\n", min(dp[n][n / 2][1], dp[n][n / 2][0]));
}