poj 1037 动态规划 + 计数，求排列布局

 这道题，黑书上p257有解题的分析，之前没看明白~~，网上搜了一大堆

看了http://jay23jack.blog.163.com/blog/static/317951942009130215813/

http://blog.csdn.net/geniusluzh/article/details/6936063这两位大牛的报告

题目的大意就是一些装饰栏，编号为1,2,3,...,n，他们的排列要遵循每个栅栏的编号要么同大于相邻的栅栏编号（a(i)>a(i-1), a(i) > a(i+1)），要么同小于相邻的栅栏编号(a(i) < a(i-1), a(i) < a(i+1))。按这种方式的每种排列按字典序排放，每种排列有一个编号，从小到大，现在给出栅栏的个数，排列的序号，要你求出这个序号对应的排列布局。

动态规划+计数

看了黑书上的感觉前面的叙述讲得很模糊甚至感觉不对。。。。就后面的结论是对的，但是他又没解释那个g[n][T].up = sum(g[n-1][i].dowm)(T<=i<=n-1)，为啥是i是从T开始的，还是看了某大牛的才明白，，，就是个对应关系，不考虑绝对高度，只考虑相对的高度

http://hi.baidu.com/xingwuzhiqing/blog/item/1e580227fd465c0c4d088d3d.html

比如在1,2,3,4,5里面选了3，那么剩下1,2,4,5，因为只考虑相对高度，所以可以对应为1,2,3,4所以后面的n-1长从3开始

设dp[i][j][0]表示以i开头，长度为j，头两块板子是上升的排列数

dp[i][j][1]表示i开头，长度为j，头两块板子是下降的排列数

那么dp[i][j][0] = sum(dp[k][j-1][1])     i =< k <= j-1

dp[i][j][1] = sum(dp[k][j-1][0])   1<=k <i

dp[1][1][0] = dp[1][1][1] = 1

这样就求出了dp[i][n][1]和dp[i][n][0]

那后看序号C出现在哪个段中这些段为排列为

dp[1][n][1], dp[1][n][0]

dp[2][n][1], dp[2][n][0]

.....

dp[n][n][1], dp[n][n][0]

若C出现在dp[i][n][1], dp[i][n][0]这个段中

求出C在这个段中的第几个C = C - sum   sum = (dp[1][n][1] + dp[1][n][0] + ... + dp[i-1][n][1] + dp[i-1][n][0])

然后当C <= dp[i][n][1]说明C出现在dp[i][n][1]这个段里面， 否则出现在dp[i][n][0]这个段里面

因为dp[i][n][0] = sum(dp[k][n-1][1])     i =< k <= n-1,;

dp[i][n][1] = sum(dp[k][n-1][1])     1=< k  < i

所以按照字典序，从小到大枚举k，从1到0的顺序枚举下降和上升

存储每个i

由于每次存储的i是经过之前的那种1,2,3,4,5选出3后，剩下1,2,4,5对应于1,2,3,4的那种方法所确定的

所以输出要返回映射为1---n的数

暴力搜索。。。。

从1-n遍历j，没有输出就ans[i]--,当ans[i]==0表示这个数是j，标记j已经被输出，下次遍历就不算进去

 

#include <iostream>
#include <cstring>
#include <cmath>
#include <cstdio>
using namespace std;

const int maxn = 25;

long long dp[maxn][maxn][2], C;

int ans[maxn];

bool visited[maxn];
int K, N;

void init();
void solve();
void output();

int main()
{
    init();
    scanf("%d", &K);
    while(K-- != 0)
    {
        scanf("%d %lld", &N, &C);
        solve();
        output();
    }
    return 0;
}

void init()
{
    memset(dp, 0, sizeof(dp));
    dp[1][1][0] = 1;
    dp[1][1][1] = 1;
    
    for(int j = 2; j <= 20; j++)
    {
        for(int i = 1; i <= j; i++)
        {
            for(int k = i; k <= j - 1; k++)
                dp[i][j][0] += dp[k][j-1][1];
            for(int k = 1; k < i; k++)
                dp[i][j][1] += dp[k][j-1][0];
        }
    }
}

void solve()
{
    bool flag;
    long long sum = 0;
    int cur, len = 2, tn = N;
    
    for(int i = 1; i <= tn; i++)
    {
        if(sum + dp[i][tn][0] + dp[i][tn][1] >= C)
        {
            ans[1] = i;
            cur = i;
            C -= sum;
            break;
        }
        sum += (dp[i][tn][0] + dp[i][tn][1]);
    }
    
    if(C <= dp[cur][tn][1])
        flag = true;
    else
    {
        C -= dp[cur][tn][1];
        flag = false;
    }
   
    tn--;
    while(tn > 0)
    {
        if(flag)
        {
            for(int i = 1; i < cur; i++)
            {
                if(dp[i][tn][0] >= C)
                {
                    cur = i;
                    ans[len++] = i;
                    break;
                }
                C -= dp[i][tn][0];
            }
        }
        else
        {
            for(int i = cur; i <= tn; i++)
            {
                if(dp[i][tn][1] >= C)
                {
                    cur = i;
                    ans[len++] = i;
                    break;
                }
                C -= dp[i][tn][1];
            }
        }
        tn--;
        flag = !flag;
    }
}

void output()
{
    memset(visited, 0, sizeof(visited));
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= N; j++)
        {
            if(!visited[j])
            {
                ans[i]--;
                if(ans[i] == 0)
                {
                    printf("%d ", j);
                    visited[j] = true;
                    break;
                }
            }
        }
    }
    printf("\n");
}