新普金娱乐网址


数学佛教牛人录23 禅语机言何人识(二)|棒喝生禅

数学JavaScript(JS)之Javascript对象

BZOJ 4818 SDOI2017 序列计数

  • 十月 27, 2018
  • 数学
  • 没有评论

pandas的数据结构介绍

咱用以下的章程导入pandas:

import pandas as pd
from pandas import Series, DataFrame
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define LL long long
using namespace std;
const int N = 20000010;
const int Mod = 20170408;
int n,P[N],tot,m,p,f[10100][101];
LL Ans,tim;
bool vis[N];

inline int gi()
{
    int x=0,res=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')res=-res;ch=getchar();}
    while(ch>='0'&&ch<='9')x=x*10+ch-48,ch=getchar();
    return x*res;
}

inline void shai()
{
    vis[1]=1;
    for(int i=2;i<=m;++i)
        {
            if(!vis[i])P[++tot]=i;
            for(int j=1;j<=tot;++j)
                {
                    if(i*P[j]>m)break;
                    vis[i*P[j]]=true;
                    if(i%P[j]==0)break;
                }
        }
}

int main()
{
    freopen("in.txt","r",stdin);
    freopen("DP.txt","w",stdout);
    n=gi();m=gi();p=gi();shai();
    f[0][0]=1ll;
    for(int i=0;i<n;++i)
        for(int j=0;j<p;++j)
            for(int k=1;k<=m;++k)
                {
                    f[i+1][(j+k)%p]+=f[i][j];
                    if(f[i+1][(j+k)%p]>Mod)
                        f[i+1][(j+k)%p]-=Mod;
                }
    Ans=(LL)f[n][0];
    memset(f,0,sizeof(f));f[0][0]=1ll;
    for(int i=0;i<n;++i)
        for(int j=0;j<p;++j)
            for(int k=1;k<=m;++k)
                {
                    if(!vis[k])continue;
                    f[i+1][(j+k)%p]+=f[i][j];
                    if(f[i+1][(j+k)%p]>Mod)
                        f[i+1][(j+k)%p]-=Mod;
                }
    Ans-=(LL)f[n][0];
    printf("%lld\n",(Ans%Mod+Mod)%Mod);
}

委指定轴及之项

抛开某条轴上一个或者多独宗十分粗略,只要一个索引数组或列表即可。使用drop方法返回的凡一个以指定轴及剔除了指定值得新目标:

In [37]: obj = pd.Series(np.arange(5),index=['a','b','c','d','e'])

In [38]: obj
Out[38]:
a    0
b    1
c    2
d    3
e    4
dtype: int32

In [39]: new_obj = obj.drop('c')

In [40]: new_obj
Out[40]:
a    0
b    1
d    3
e    4
dtype: int32

In [41]: obj.drop(['d','c'])
Out[41]:
a    0
b    1
e    4
dtype: int32

于DataFrame,可以去除任意轴上之索引值:

In [42]: data = pd.DataFrame(np.arange(16).reshape((4,4)),
    ...: index=['Ohio','Colorado','Utah','New York'],
    ...: columns=['one','two','three','four'])

In [43]: data
Out[43]:
          one  two  three  four
Ohio        0    1      2     3
Colorado    4    5      6     7
Utah        8    9     10    11
New York   12   13     14    15

In [44]: data.drop(['Colorado','Ohio'])
Out[44]:
          one  two  three  four
Utah        8    9     10    11
New York   12   13     14    15

In [45]: data.drop('two',axis=1)
Out[45]:
          one  three  four
Ohio        0      2     3
Colorado    4      6     7
Utah        8     10    11
New York   12     14    15

In [46]: data.drop(['two','four'],axis=1)
Out[46]:
          one  three
Ohio        0      2
Colorado    4      6
Utah        8     10
New York   12     14

以上。

      1.f[i][j][0/1]表示第i个数,模p为j,有无质数的状况;这种自我勾勒及一半住下来了,因为自己发觉了次种DP可以优化。

DataFrame

DataFrame是一个表格型的数据结构,它涵盖一组有序的排列,每列可以是差的值类型(数价、字符串、布尔值等)。DataFrame既来行索引为产生列索引,它可让看做由Series组成的字典(共用同一个目)。

结构DataFrame的点子有为数不少,最常用之均等栽是直传入一个出于相当丰富列表或NumPy数组组成的字典:

In [49]: data = {'state':['Ohio','Ohio','Ohio','Nevada','Nevada'],
    ...:     ...: 'year':[2000,2001,2002,2001,2002],
    ...:     ...: 'pop':[1.5,1.7,3.6,2.4,2.9]}

In [50]: frame = pd.DataFrame(data)

DataFrame会自动抬高索引(和Series一样),且一切列会被有序排列:

In [51]: frame
Out[51]:
   pop   state  year
0  1.5    Ohio  2000
1  1.7    Ohio  2001
2  3.6    Ohio  2002
3  2.4  Nevada  2001
4  2.9  Nevada  2002

倘若指定了排序列,则DataFrame的排就见面照指定顺序进行排列:

In [52]: pd.DataFrame(data,columns=['year','state','pop'])
Out[52]:
   year   state  pop
0  2000    Ohio  1.5
1  2001    Ohio  1.7
2  2002    Ohio  3.6
3  2001  Nevada  2.4
4  2002  Nevada  2.9

跟Series一样,如果传入的排于数中找寻不交,就会出NA值:

In [56]: frame2 = pd.DataFrame(data,columns=['year','state','pop',
    ...: 'debt'],index=['one','two','three','four','five'])

In [57]: frame2
Out[57]:
       year   state  pop debt
one    2000    Ohio  1.5  NaN
two    2001    Ohio  1.7  NaN
three  2002    Ohio  3.6  NaN
four   2001  Nevada  2.4  NaN
five   2002  Nevada  2.9  NaN

In [58]: frame2.columns
Out[58]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

透过类似字典标记的主意或者性能之法门,可以用DataFrame的排列获取为一个Series:

In [59]: frame2['state']
Out[59]:
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
Name: state, dtype: object

In [60]: frame2.year
Out[60]:
one      2000
two      2001
three    2002
four     2001
five     2002
Name: year, dtype: int64

返的Series拥有原DataFrame相同之目,且该name属性也都给相应地设置好了。行也可经岗位或名称地方式进行得、比如用索引字段loc。

In [62]: frame2.loc['three']
Out[62]:
year     2002
state    Ohio
pop       3.6
debt      NaN
Name: three, dtype: object

In [64]: frame2.iloc[0]
Out[64]:
year     2000
state    Ohio
pop       1.5
debt      NaN
Name: one, dtype: object

列好通过赋值的法子开展修改。例如,我们得给空的”debt”列赋上一个标量值或同组值:

In [65]: frame2['debt'] = 16.5

In [66]: frame2
Out[66]:
       year   state  pop  debt
one    2000    Ohio  1.5  16.5
two    2001    Ohio  1.7  16.5
three  2002    Ohio  3.6  16.5
four   2001  Nevada  2.4  16.5
five   2002  Nevada  2.9  16.5

In [67]: frame2['debt'] = np.arange(5)

In [68]: frame2
Out[68]:
       year   state  pop  debt
one    2000    Ohio  1.5     0
two    2001    Ohio  1.7     1
three  2002    Ohio  3.6     2
four   2001  Nevada  2.4     3
five   2002  Nevada  2.9     4

将列表或数组赋值给有列时,其尺寸要跟DataFrame的长相匹配。若赋值的是一个Series,就会准确匹配DataFrame的目录,所有的空位都见面于填上缺乏失值:

In [71]: val = pd.Series([-1.2,-1.5,-1.7],index=['two','four','five'])

In [72]: frame2['debt'] = val

In [73]: frame2
Out[73]:
       year   state  pop  debt
one    2000    Ohio  1.5   NaN
two    2001    Ohio  1.7  -1.2
three  2002    Ohio  3.6   NaN
four   2001  Nevada  2.4  -1.5
five   2002  Nevada  2.9  -1.7

否无有的列赋值会创建有一个新列。关键字del用于去列:

In [82]: frame2['eastern'] = frame2.state == 'Ohio'

In [83]: frame2
Out[83]:
       year   state  pop  debt  eastern
one    2000    Ohio  1.5   NaN     True
two    2001    Ohio  1.7  -1.2     True
three  2002    Ohio  3.6   NaN     True
four   2001  Nevada  2.4  -1.5    False
five   2002  Nevada  2.9  -1.7    False

In [84]: del frame2['eastern']

In [85]: frame2.columns
Out[85]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

由此索引方式回的排列是应和数据的视图,不是副本。

其余一样栽常见的多少形式是嵌套字典:

In [86]: pop = {'Nevada':{2001:2.4,2002:2.9},
    ...: 'Ohio':{2000:1.5,2001:1.7,2002:3.6}}

In [87]: frame3 = pd.DataFrame(pop)

In [88]: frame3
Out[88]:
      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7
2002     2.9   3.6

外层字典的键作为列,内层键作为行索引

鉴于Series组成的字典差不多也是一律的用法:

In [95]: pdata = {'Ohio':frame3['Ohio'][:-1],
    ...: 'Nevada':frame3['Nevada'][:2]}

In [96]: pd.DataFrame(pdata)
Out[96]:
      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7

可输入被DataFrame构造器的数码:

一经安了DataFrame的index和columns的name属性,这些消息为会见受出示出来:

In [97]: frame3.index.name = 'year'

In [98]: frame3.columns.name = 'state'

In [99]: frame3
Out[99]:
state  Nevada  Ohio
year
2000      NaN   1.5
2001      2.4   1.7
2002      2.9   3.6

跟Series一样,values属性也会以二维ndarray的样式返回DataFrame中的数目。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define LL long long
using namespace std;
const int N = 20000010;
const int Mod = 20170408;
struct Matrix{
    int T[105][105];
}S0,M0_1,M1_1,M0_2,M1_2,ans;
int n,P[N],tot,m,p,foo[200];
LL Ans;
bool vis[N];

inline int gi()
{
    int x=0,res=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')res=-res;ch=getchar();}
    while(ch>='0'&&ch<='9')x=x*10+ch-48,ch=getchar();
    return x*res;
}

inline void shai()
{
    vis[1]=1;
    for(int i=2;i<=m;++i)
        {
            if(!vis[i])P[++tot]=i;
            for(int j=1;j<=tot;++j)
                {
                    if(i*P[j]>m)break;
                    vis[i*P[j]]=true;
                    if(i%P[j]==0)break;
                }
        }
}

inline Matrix Mul(Matrix a,Matrix b,int I,int K,int J)
{
    Matrix S=S0;
    for(int i=0;i<I;++i)
        for(int j=0;j<J;++j)
            for(int k=0;k<K;++k)
                S.T[i][j]=(S.T[i][j]+(LL)a.T[i][k]*b.T[k][j])%Mod;
    return S;
}

inline Matrix Qpow(Matrix S,Matrix d,int z,int I,int K,int J)
{
    for(;z;z>>=1,d=Mul(d,d,I,K,J))
        if(z&1)S=Mul(S,d,I,K,J);
    return S;
}

int main()
{
    freopen("count.in","r",stdin);
    freopen("count.out","w",stdout);
    n=gi();m=gi();p=gi();shai();
    M0_1.T[0][0]=M0_2.T[0][0]=1ll;
    for(int i=1;i<=m;++i)++foo[i%p];
    for(int i=0;i<p;++i)
        for(int j=0;j<p;++j)
            {
                int st=(i+j)%p;
                M1_1.T[i][st]+=foo[j];
                if(M1_1.T[i][st]>=Mod)
                    M1_1.T[i][st]-=Mod;
            }
    ans = Qpow(M0_1,M1_1,n,p,p,p);
    Ans+=ans.T[0][0];
    for(int i=0;i<p;++i)foo[i]=0;
    for(int i=1;i<=m;++i)
        if(vis[i])++foo[i%p];
    for(int i=0;i<p;++i)
        for(int j=0;j<p;++j)
            {
                int st=(i+j)%p;
                M1_2.T[i][st]+=foo[j];
                if(M1_2.T[i][st]>=Mod)
                    M1_2.T[i][st]-=Mod;
            }
    ans = Qpow(M0_2,M1_2,n,p,p,p);
    Ans-=ans.T[0][0];
    printf("%lld\n",(Ans%Mod+Mod)%Mod);
}

双重索引

pandas对象的一个着重方法是reindex,其打算是创一个适应新索引的新目标

In [11]: obj = pd.Series([-4.5,7.2,-5.3,3.6],index=['d','b','a','c'])

In [12]: obj
Out[12]:
d   -4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

In [13]: obj2 = obj.reindex(['a','b','c','d','e'])

In [14]: obj2
Out[14]:
a   -5.3
b    7.2
c    3.6
d   -4.5
e    NaN
dtype: float64

In [15]: obj.reindex(['a','b','c','d','e'],fill_value=0)
Out[15]:
a   -5.3
b    7.2
c    3.6
d   -4.5
e    0.0
dtype: float64

假定某个索引值当前不有,就引入缺失值。

于日序列这样的静止数据,重新索引时可能得开一些插值处理,method选项即可直达这目的。

In [16]: obj3 = pd.Series(['blue','purple','yellow'],index=[0,2,4])

In [17]: obj3.reindex(range(6),method='ffill')
Out[17]:
0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

reindex的(插值)method选项:

参数 说明
ffill或pad 前向填充(或搬运)值
bfill或backfill 后向填充(或搬运)值

于DataFrame,reindex可以改(行)索引、列,或少单还改。如果单传入一个班则会重新索引行:

In [25]: frame2 = frame.reindex(['a','b','c','d'])

In [26]: frame = pd.DataFrame(np.arange(9).reshape((3,3)),index=['a','c','d'],
    ...: columns=['Ohio','Texas','California'])

In [27]: frame2 = frame.reindex(['a','b','c','d'])

In [29]: frame2
Out[29]:
   Ohio  Texas  California
a   0.0    1.0         2.0
b   NaN    NaN         NaN
c   3.0    4.0         5.0
d   6.0    7.0         8.0

故columns关键字即可再次索引列,也只是同时对行和排进行双重索引,而插值则不得不按行应用(即轴0)。

运loc的标签索引功能,重新索引任务可以变得重精简:

In [33]: states = ['Texas','Utah','California']

In [34]: frame.loc[['a','b','c','d'],states]
Out[34]:
   Texas  Utah  California
a    1.0   NaN         2.0
b    NaN   NaN         NaN
c    4.0   NaN         5.0
d    7.0   NaN         8.0

reindex函数的参数:

  

文章与载于本人之博客:http://www.viljw1557.cn

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define LL long long
using namespace std;
const int N = 20000010;
const int Mod = 20170408;
struct Matrix{
    int T[105][105];
}S0,M0,M1;
int n,P[N],tot,m,p;
LL Ans;
bool vis[N];

inline int gi()
{
    int x=0,res=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')res=-res;ch=getchar();}
    while(ch>='0'&&ch<='9')x=x*10+ch-48,ch=getchar();
    return x*res;
}

inline void shai()
{
    vis[1]=1;
    for(int i=2;i<=m;++i)
        {
            if(!vis[i])P[++tot]=i;
            for(int j=1;j<=tot;++j)
                {
                    if(i*P[j]>m)break;
                    vis[i*P[j]]=true;
                    if(i%P[j]==0)break;
                }
        }
}

inline Matrix Mul(Matrix a,Matrix b,int I,int K,int J)
{
    Matrix S=S0;
    for(int i=0;i<I;++i)
        for(int j=0;j<J;++j)
            for(int k=0;k<K;++k)
                S.T[i][j]=((LL)(S.T[i][j])+((LL)a.T[i][k]*(LL)b.T[k][j]%Mod))%Mod;
    return S;
}

inline Matrix Qpow(Matrix s,Matrix d,int z,int I,int K,int J)
{
    Matrix S=s;
    for(;z;z>>=1,d=Mul(d,d,I,K,J))
        if(z&1)S=Mul(S,d,I,K,J);
    return S;
}

int main()
{
    freopen("in.txt","r",stdin);
    freopen("MT.txt","w",stdout);
    n=gi();m=gi();p=gi();shai();
    M0.T[0][0]=1ll;
    for(int i=0;i<p;++i)
        for(int j=1;j<=m;++j)
            {
                M1.T[i][(i+j)%p]++;
                M1.T[i][(i+j)%p]%=Mod;
            }
    Matrix ans1 = Qpow(M0,M1,n,p,p,p);
    Ans+=ans1.T[0][0];M0=M1=S0;M0.T[0][0]=1ll;
    for(int i=0;i<p;++i)
        for(int j=1;j<=m;++j)
            {
                if(!vis[j])continue;
                M1.T[i][(i+j)%p]++;
                M1.T[i][(i+j)%p]%=Mod;
            }
    Matrix ans2 = Qpow(M0,M1,n,p,p,p);
    Ans-=ans2.T[0][0];
    printf("%lld\n",(Ans%Mod+Mod)%Mod);
}

基本功能

介绍操作Series和DataFrame中之多少的为主手段。

 

Series

Series是同样栽恍若于一维数组的对象,它由同组数(各种NumPy数据类型)以及同样组以及的休戚相关的数额标签(即索引)组成。由同样组数据就是不过出最简便易行的Series:

In [6]: obj = pd.Series([4,7,-5,3])

In [7]: obj
Out[7]:
0    4
1    7
2   -5
3    3
dtype: int64

Series的字符串表现呢:索引在左手,值当右侧。由于无啊数据指定索引,于是会自动创建一个0到N-1(N为数据的长)的整数索引。可以通过Series的values和index属性获取其数组表示形式以及目录对象:

In [8]: obj.values
Out[8]: array([ 4,  7, -5,  3], dtype=int64)

In [9]: obj.index
Out[9]: RangeIndex(start=0, stop=4, step=1)

习以为常,我们期望创建的Series带有一个足以本着各个数据点进行标记的目:

In [10]: obj2 = pd.Series([4,7,-5,3],index=['d','b','a','c'])

In [12]: obj2
Out[12]:
d    4
b    7
a   -5
c    3
dtype: int64

与平常NumPy数组相比,可以经索引的法选择Series中之单个或一致组值:

In [13]: obj2['a']
Out[13]: -5

In [15]: obj2['d'] = 7

In [18]: obj2[['c','a','d']]
Out[18]:
c    3
a   -5
d    7
dtype: int64

NumPy数组运算(如根据布尔型数组进行过滤、标量乘法、应用数学函数等)都见面保留索引和价值期间的连天:

In [19]: obj2
Out[19]:
d    7
b    7
a   -5
c    3
dtype: int64

In [21]: obj2[obj2>0]
Out[21]:
d    7
b    7
c    3
dtype: int64

In [22]: obj2*2
Out[22]:
d    14
b    14
a   -10
c     6
dtype: int64

In [23]: np.exp(obj2)
Out[23]:
d    1096.633158
b    1096.633158
a       0.006738
c      20.085537
dtype: float64

还足以拿Series看成是一个定长的平稳字典,因为它们是寻找引值到数据值的一个映射。

In [24]: 'b' in obj2
Out[24]: True

In [25]: 'e' in obj2
Out[25]: False

若数据在一个字典中,也堪经之字典来创造Series,索引就是本字典的键:

In [26]: sdata = {'Ohio':35000,'Texas':71000,'Oregon':16000,'Utah':5000}

In [27]: obj3 = pd.Series(sdata)

In [28]: obj3
Out[28]:
Ohio      35000
Oregon    16000
Texas     71000
Utah       5000
dtype: int64

再度拘留一个例子:

In [30]: states = ['California','Ohio','Oregon','Texas']

In [31]: obj4 = pd.Series(sdata,index=states)

In [32]: obj4
Out[32]:
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

当此事例中,sdata跟states索引相配合的那3个值会被摸出来并坐相应的职位及,但鉴于“California”所对应的sdata值找不交,所以该结果就是吧NaN(即“非数字”,在pandas中,它用于表示缺失或者NA值)。pandas的isnulllnotnull函数可用于检测缺失数据:

In [33]: pd.isnull(obj4)
Out[33]:
California     True
Ohio          False
Oregon        False
Texas         False
dtype: bool

In [34]: pd.notnull(obj4)
Out[34]:
California    False
Ohio           True
Oregon         True
Texas          True
dtype: bool

对于众多用而言,Series最着重之一个力量是:它当算术运算被见面自行对一头不同索引的数量。

In [35]: obj3
Out[35]:
Ohio      35000
Oregon    16000
Texas     71000
Utah       5000
dtype: int64

In [36]: obj4
Out[36]:
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
dtype: float64

In [37]: obj3 + obj4
Out[37]:
California         NaN
Ohio           70000.0
Oregon         32000.0
Texas         142000.0
Utah               NaN
dtype: float64

Series对象自我及其索引都起一个name属性,该属性跟pandas其他的要意义关系颇仔细:

In [38]: obj4.name = 'population'

In [39]: obj4.index.name = 'state'

In [40]: obj4
Out[40]:
state
California        NaN
Ohio          35000.0
Oregon        16000.0
Texas         71000.0
Name: population, dtype: float64

Series的目录可以经过赋值的办法就地修改:

In [43]: obj.index = ['Bob','Steve','Jeff','Ryan']

In [44]: obj
Out[44]:
Bob      4
Steve    7
Jeff    -5
Ryan     3
dtype: int64

  

目对象

pandas的目录对象负责管理轴标签和外元数据(比如轴名称等)。构建Series或DataFrame时,所用到之别数组或另队的签还见面吃更换成为一个Index:

In [4]: obj = pd.Series(range(3),index=['a','b','c'])

In [5]: index = obj.index

In [6]: index
Out[6]: Index(['a', 'b', 'c'], dtype='object')

In [7]: index[1:]
Out[7]: Index(['b', 'c'], dtype='object')

Index对象时不足修改的,因此用户不能够对该进行修改。

除去助长得像屡次组,Index的意义吗相近一个恒定大小的集聚。

Index的办法和性能:

   80%:我们发现状态转移方程是一个首先维线性递推,第二维稳定一阶变换。然后发现p只出100,于是就好上矩阵快速幂。建立转移矩阵就是方的DP式子。复杂度O(mp+p^3logn)

  

解题报告:

  求:n个数(顺序可改),值域为[1,m],和为p的倍数,且这些往往里面来质数的方案往往凡是微?

1.题面

  30% O(nmp)DP;

    注意到各国一个勤得任意取,就是怪肯定的有着DP性质了。那么来少栽DP方法:

      2.f[i][j]和g[i][j]各自表示瞎几把胡取数和免获取质数的状,求来后相减即可(容斥思想)。

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#define LL long long
using namespace std;
const int N = 20000010;
int n,P[N],tot,m,k;
LL Ans,tim;
bool vis[N];
inline int gi()
{
    int x=0,res=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')res=-res;ch=getchar();}
    while(ch>='0'&&ch<='9')x=x*10+ch-48,ch=getchar();
    return x*res;
}

inline void shai()
{
    vis[1]=1;
    for(int i=2;i<=m;++i)
        {
            if(!vis[i])P[++tot]=i;
            for(int j=1;j<=tot;++j)
                {
                    if(i*P[j]>m)break;
                    vis[i*P[j]]=true;
                    if(i%P[j]==0)break;
                }
        }
}

inline void dfs(int dep,int flag,int sum)
{
    if(dep==n){if(flag==1&&(sum%k==0))Ans++;return;}
    for(int x=1;x<=m;++x)
        if(vis[x]==false)dfs(dep+1,1,sum+x);
        else dfs(dep+1,flag,sum+x);
}
int main()
{
    freopen("in.txt","r",stdin);
    freopen("BL.txt","w",stdout);
    n=gi();m=gi();k=gi();shai();
    dfs(0,0,0);cout<<Ans%20170408<<endl;
}

   100%:我们发现时间TLE在于构建矩阵时之mp太死,然后我们发现这个转移重复了多坏,于是可以经过事先处理贡献优化及p^2; 

  0% O(n^n)爆搜,没什么好讲的,用来拍DP;

刚出炉的探访选题,还是山东底。

废话不说上题解。

//然后而就华丽的AC了!

  

自古山东生数学与网络流,堪称思维的佛殿,比某地数据结构成风好多矣。

相关文章

No Comments, Be The First!
近期评论
    分类目录
    功能
    网站地图xml地图