TC SRM 638 DIV1 600 NarrowPassage2

Problem Statement

在一个狭长的通道中有$n$只狼，每只狼的体积为$size_i$，如果相邻的两只狼体积不超过$m$，则可以交换位置，求可以有多少种排列。

$n≤50,1≤m≤1,000,000,000$

Tutorial

每次选出区间中体积最大的狼，如果其他狼可以越过它，那么即可在整个区间里自由移动，而不能越过它的狼则被隔离到两个区间里，可以分治。

区间总共有$n$只狼，能自由移动的狼个数为$cnt$，那么最后结果等于$$solve(l)*solve(r)*A_{n}^{cnt}$$

 

给定一些拓扑关系然后统计一些信息的题，算上这题最近遇到3道:
Permutation，结构是树，但因为要统计逆序对数比较烦，树形dp

局部极小值，因为是网格，而且标记的是局部极小值，所以可以通过确定较少的点状压dp计算结果

 

关于本题，我想到的部分

首先，可以在区间内畅通无阻的狼可以随便取一个位置

然后一个点如果两边的点都过不去，就可以分成2个子问题

因为“两边的点都过不去”这个条件并不清晰，所以我放弃了分治这个思路

正解利用了区间体积最大这个性质实现了分治

路曼曼其修远兮……

局部极小值和本题都有一个类似DAG的模型，所以我开始都试着往图论+dp的方向想==

现在我可以得到一个简洁的结论 DAG拓扑排序的结果有多少种可能 是NP问题

应该可以帮助以后少走一些弯路吧

还有关于拓扑问题的突破口其实也很简单:最值

然后就是挖性质、玩套路的本事了==

#include <set>
#include <ctime>
#include <queue>
#include <cstdio>
#include <bitset>
#include <cctype>
#include <bitset>
#include <cstdlib>
#include <cassert>
#include <cstring>
#include <iostream>
#include <algorithm>
#define inf (1<<30)
#define INF (1ll<<62)
#define fi first
#define se second
#define rep(x,s,t) for(register int x=s,t_=t;x<t_;++x)
#define per(x,s,t) for(register int x=t-1,s_=s;x>=s_;--x)
#define travel(x) for(int I=last[x],to;I&&(to=e[I].to);I=e[I].nxt)
#define prt(x) cout<<#x<<":"<<x<<" "
#define prtn(x) cout<<#x<<":"<<x<<endl
#define pb(x) push_back(x)
#define hash asfmaljkg
#define rank asfjhgskjf
#define y1 asggnja
#define y2 slfvm
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;
template<class T>void nt(T x){
    if(!x)return;
    nt(x/10);
    putchar(x%10+'0');
}
template<class T>void pt(T x){
    if(x<0)putchar('-'),x=-x;
    if(!x)putchar('0');
    else nt(x);
}
template<class T>void ptn(T x){
    pt(x);putchar('\n');
}
template<class T>void pts(T x){
    pt(x);putchar(' ');
}
template<class T>inline void Max(T &x,T y){if(x<y)x=y;}
template<class T>inline void Min(T &x,T y){if(x>y)x=y;}

const int maxn=55;
const int mod=1000000007;
class NarrowPassage2 {
public:
    ll cnk[maxn][maxn],fac[maxn];
    int m;
    int solve(vector<int>d){
        if(d.size()<=1)return 1;
        int n=d.size();
        int v=-1,id;
        rep(i,0,n){
            if(d[i]>v){
                v=d[i];
                id=i;
            }
        }
        vector<int>l,r;
        int cnt=0;
        rep(i,0,id){
            if(d[i]+v<=m)cnt++;
            else l.pb(d[i]);
        }
        rep(i,id+1,n){
            if(d[i]+v<=m)cnt++;
            else r.pb(d[i]);
        }
        return (ll)solve(l)*solve(r)%mod*cnk[n][cnt]%mod*fac[cnt]%mod;
    }
    int count(vector<int>d, int maximum) {
        cnk[0][0]=fac[0]=1;
        rep(i,1,d.size()+1)
            fac[i]=fac[i-1]*i%mod;
        rep(i,0,d.size()+1){
            rep(j,1,i)cnk[i][j]=(cnk[i-1][j-1]+cnk[i-1][j])%mod;
            cnk[i][0]=cnk[i][i]=1;
        }
        m=maximum;
        return solve(d);
    }
};