码迷，mamicode.com
首页 > 其他好文 > 详细

HDU 5568 - BestCoder Round #63 - sequence2

时间：2015-11-22 20:14:31      阅读：134      评论：0      收藏：0      [点我收藏+]

标签：

 

题目链接 : http://acm.hdu.edu.cn/showproblem.php?pid=5568

 

题意 : 

给一个长度已知的序列, 给一个值k, 问该序列中有多少种长度为k的上升子序列

 

思路 :

日常读错题..理解成有多少种值不同且长度为k的上升子序列了,

而原意是只要任意两个子序列的下标不同即可

就按官方题解的解法, dp, 用二维数组dp[i][j]位置i的数作为子序列中第j个数的方案数

故遍历序列, 对一个位置i, 它作为序列中第k大的值, 如果在它之前有b[i] > b[j], 那么dp[i][k] += dp[j][k-1]

而且要用大数存放, 随便举个例子, 给出100个数1到100, 给出k=50, 答案即为C(50, 100);

 

dp代码 :

技术分享 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>

using namespace std;

const int N = 1e2+10;

#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4
class BigNum {
    private:
        int a[40]; //可以控制大数的位数
        int len;
    public:
        BigNum() {
            len=1;    //构造函数
            memset(a,0,sizeof(a));
        }
        BigNum(const int); //将一个int类型的变量转化成大数
        BigNum(const char*); //将一个字符串类型的变量转化为大数
        BigNum(const BigNum &); //拷贝构造函数
        BigNum &operator=(const BigNum &); //重载赋值运算符，大数之间进行赋值运算
        friend istream& operator>>(istream&,BigNum&); //重载输入运算符
        friend ostream& operator<<(ostream&,BigNum&); //重载输出运算符
        BigNum operator+(const BigNum &)const; //重载加法运算符，两个大数之间的相加运算
        BigNum operator-(const BigNum &)const; //重载减法运算符，两个大数之间的相减运算
        BigNum operator*(const BigNum &)const; //重载乘法运算符，两个大数之间的相乘运算
        BigNum operator/(const int &)const; //重载除法运算符，大数对一个整数进行相除运算
        BigNum operator^(const int &)const; //大数的n次方运算
        int operator%(const int &)const; //大数对一个int类型的变量进行取模运算
        bool operator>(const BigNum &T)const; //大数和另一个大数的大小比较
        bool operator>(const int &t)const; //大数和一个int类型的变量的大小比较
        void print(); //输出大数
};
BigNum::BigNum(const int b) { //将一个int类型的变量转化为大数
    int c,d=b;
    len=0;
    memset(a,0,sizeof(a));
    while(d>MAXN) {
        c=d-(d/(MAXN+1))*(MAXN+1);
        d=d/(MAXN+1);
        a[len++]=c;
    }
    a[len++]=d;
}
BigNum::BigNum(const char *s) { //将一个字符串类型的变量转化为大数
    int t,k,index,L,i;
    memset(a,0,sizeof(a));
    L=strlen(s);
    len=L/DLEN;
    if(L%DLEN)len++;
    index=0;
    for(i=L-1; i>=0; i-=DLEN) {
        t=0;
        k=i-DLEN+1;
        if(k<0)k=0;
        for(int j=k; j<=i; j++)
            t=t*10+s[j]-‘0‘;
        a[index++]=t;
    }
}
BigNum::BigNum(const BigNum &T):len(T.len) { //拷贝构造函数
    int i;
    memset(a,0,sizeof(a));
    for(i=0; i<len; i++)
        a[i]=T.a[i];
}
BigNum & BigNum::operator=(const BigNum &n) { //重载赋值运算符，大数之间赋值运算
    int i;
    len=n.len;
    memset(a,0,sizeof(a));
    for(i=0; i<len; i++)
        a[i]=n.a[i];
    return *this;
}
istream& operator>>(istream &in,BigNum &b) {
    char ch[MAXSIZE*4];
    int i=-1;
    in>>ch;
    int L=strlen(ch);
    int count=0,sum=0;
    for(i=L-1; i>=0;) {
        sum=0;
        int t=1;
        for(int j=0; j<4&&i>=0; j++,i--,t*=10) {
            sum+=(ch[i]-‘0‘)*t;
        }
        b.a[count]=sum;
        count++;
    }
    b.len=count++;
    return in;
}
ostream& operator<<(ostream& out,BigNum& b) { //重载输出运算符
    int i;
    cout<<b.a[b.len-1];
    for(i=b.len-2; i>=0; i--) {
        printf("%04d",b.a[i]);
    }
    return out;
}
BigNum BigNum::operator+(const BigNum &T)const { //两个大数之间的相加运算
    BigNum t(*this);
    int i,big;
    big=T.len>len?T.len:len;
    for(i=0; i<big; i++) {
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN) {
            t.a[i+1]++;
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0)
        t.len=big+1;
    else t.len=big;
    return t;
}
BigNum BigNum::operator-(const BigNum &T)const { //两个大数之间的相减运算
    int i,j,big;
    bool flag;
    BigNum t1,t2;
    if(*this>T) {
        t1=*this;
        t2=T;
        flag=0;
    } else {
        t1=T;
        t2=*this;
        flag=1;
    }
    big=t1.len;
    for(i=0; i<big; i++) {
        if(t1.a[i]<t2.a[i]) {
            j=i+1;
            while(t1.a[j]==0)
                j++;
            t1.a[j--]--;
            while(j>i)
                t1.a[j--]+=MAXN;
            t1.a[i]+=MAXN+1-t2.a[i];
        } else t1.a[i]-=t2.a[i];
    }
    t1.len=big;
    while(t1.a[len-1]==0 && t1.len>1) {
        t1.len--;
        big--;
    }
    if(flag)
        t1.a[big-1]=0-t1.a[big-1];
    return t1;
}
BigNum BigNum::operator*(const BigNum &T)const { //两个大数之间的相乘
    BigNum ret;
    int i,j,up;
    int temp,temp1;
    for(i=0; i<len; i++) {
        up=0;
        for(j=0; j<T.len; j++) {
            temp=a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN) {
                temp1=temp-temp/(MAXN+1)*(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            } else {
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0)
            ret.a[i+j]=up;
    }
    ret.len=i+j;
    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
    return ret;
}
BigNum BigNum::operator/(const int &b)const { //大数对一个整数进行相除运算
    BigNum ret;
    int i,down=0;
    for(i=len-1; i>=0; i--) {
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
    }
    ret.len=len;
    while(ret.a[ret.len-1]==0 && ret.len>1)
        ret.len--;
    return ret;
}
int BigNum::operator%(const int &b)const { //大数对一个 int类型的变量进行取模
    int i,d=0;
    for(i=len-1; i>=0; i--)
        d=((d*(MAXN+1))%b+a[i])%b;
    return d;
}
BigNum BigNum::operator^(const int &n)const { //大数的n次方运算
    BigNum t,ret(1);
    int i;
    if(n<0)exit(-1);
    if(n==0)return 1;
    if(n==1)return *this;
    int m=n;
    while(m>1) {
        t=*this;
        for(i=1; (i<<1)<=m; i<<=1)
            t=t*t;
        m-=i;
        ret=ret*t;
        if(m==1)ret=ret*(*this);
    }
    return ret;
}
bool BigNum::operator>(const BigNum &T)const { //大数和另一个大数的大小比较
    int ln;
    if(len>T.len)return true;
    else if(len==T.len) {
        ln=len-1;
        while(a[ln]==T.a[ln]&&ln>=0)
            ln--;
        if(ln>=0 && a[ln]>T.a[ln])
            return true;
        else
            return false;
    } else
        return false;
}

bool BigNum::operator>(const int &t)const { //大数和一个int类型的变量的大小比较
    BigNum b(t);
    return *this>b;
}
void BigNum::print() { //输出大数
    int i;
    printf("%d",a[len-1]);
    for(i=len-2; i>=0; i--)
        printf("%04d",a[i]);
    printf("\n");
}

int a[N];
BigNum dp[N][N];

void Init(int n)
{
    for(int i = 0; i <= n; i++) {
        for(int j = 0; j <= n; j++) {
            dp[i][j] = 0;
        }
    }
    dp[0][0] = 1;
}

int main()
{
    int n, k;

    while(scanf("%d %d", &n, &k) != EOF) {
        Init(n);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
        }
        for(int i = 1; i <= n; i++) {
            for(int k = 1; k <= n; k++) {
                for(int j = 0; j < i; j++) {
                    if(a[i] > a[j]) {
                        dp[i][k] = dp[i][k] + dp[j][k-1];
                    }
                }
            }
        }
        BigNum ans = 0;
        for(int i = k; i <= n; i++) {
            ans = ans + dp[i][k];
        }
        ans.print();
    }

    return 0;
}
View Code

 

有一种更好的dp方法, 参考其他大牛写的

原来的dp, 复杂度是O(n*n*k)

而这一种用到树状数组, 可以做到O(n*logn*k)

先对原数组记录下标和值, 按值进行升序排序

之后对于第num个数从1到k, 遍历每一个数a[j]

在这个数的原位置插入dp[j][num], 并用dp[j][num]加上满足以下条件的数目总和

1. 位置在 a[j] 原位置的前面 (这个通过树状数组完成了)

2. 值比 a[j] 代表的值小 (这点通过排序完成了)

 

代码 :

技术分享 
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>

using namespace std;

const int N = 1e2+10;

#define MAXN 9999
#define MAXSIZE 1010
#define DLEN 4
class BigNum {
    private:
        int a[40]; //可以控制大数的位数
        int len;
    public:
        BigNum() {
            len=1;    //构造函数
            memset(a,0,sizeof(a));
        }
        BigNum(const int); //将一个int类型的变量转化成大数
        BigNum(const char*); //将一个字符串类型的变量转化为大数
        BigNum(const BigNum &); //拷贝构造函数
        BigNum &operator=(const BigNum &); //重载赋值运算符，大数之间进行赋值运算
        friend istream& operator>>(istream&,BigNum&); //重载输入运算符
        friend ostream& operator<<(ostream&,BigNum&); //重载输出运算符
        BigNum operator+(const BigNum &)const; //重载加法运算符，两个大数之间的相加运算
        BigNum operator-(const BigNum &)const; //重载减法运算符，两个大数之间的相减运算
        BigNum operator*(const BigNum &)const; //重载乘法运算符，两个大数之间的相乘运算
        BigNum operator/(const int &)const; //重载除法运算符，大数对一个整数进行相除运算
        BigNum operator^(const int &)const; //大数的n次方运算
        int operator%(const int &)const; //大数对一个int类型的变量进行取模运算
        bool operator>(const BigNum &T)const; //大数和另一个大数的大小比较
        bool operator>(const int &t)const; //大数和一个int类型的变量的大小比较
        void print(); //输出大数
};
BigNum::BigNum(const int b) { //将一个int类型的变量转化为大数
    int c,d=b;
    len=0;
    memset(a,0,sizeof(a));
    while(d>MAXN) {
        c=d-(d/(MAXN+1))*(MAXN+1);
        d=d/(MAXN+1);
        a[len++]=c;
    }
    a[len++]=d;
}
BigNum::BigNum(const char *s) { //将一个字符串类型的变量转化为大数
    int t,k,index,L,i;
    memset(a,0,sizeof(a));
    L=strlen(s);
    len=L/DLEN;
    if(L%DLEN)len++;
    index=0;
    for(i=L-1; i>=0; i-=DLEN) {
        t=0;
        k=i-DLEN+1;
        if(k<0)k=0;
        for(int j=k; j<=i; j++)
            t=t*10+s[j]-‘0‘;
        a[index++]=t;
    }
}
BigNum::BigNum(const BigNum &T):len(T.len) { //拷贝构造函数
    int i;
    memset(a,0,sizeof(a));
    for(i=0; i<len; i++)
        a[i]=T.a[i];
}
BigNum & BigNum::operator=(const BigNum &n) { //重载赋值运算符，大数之间赋值运算
    int i;
    len=n.len;
    memset(a,0,sizeof(a));
    for(i=0; i<len; i++)
        a[i]=n.a[i];
    return *this;
}
istream& operator>>(istream &in,BigNum &b) {
    char ch[MAXSIZE*4];
    int i=-1;
    in>>ch;
    int L=strlen(ch);
    int count=0,sum=0;
    for(i=L-1; i>=0;) {
        sum=0;
        int t=1;
        for(int j=0; j<4&&i>=0; j++,i--,t*=10) {
            sum+=(ch[i]-‘0‘)*t;
        }
        b.a[count]=sum;
        count++;
    }
    b.len=count++;
    return in;
}
ostream& operator<<(ostream& out,BigNum& b) { //重载输出运算符
    int i;
    cout<<b.a[b.len-1];
    for(i=b.len-2; i>=0; i--) {
        printf("%04d",b.a[i]);
    }
    return out;
}
BigNum BigNum::operator+(const BigNum &T)const { //两个大数之间的相加运算
    BigNum t(*this);
    int i,big;
    big=T.len>len?T.len:len;
    for(i=0; i<big; i++) {
        t.a[i]+=T.a[i];
        if(t.a[i]>MAXN) {
            t.a[i+1]++;
            t.a[i]-=MAXN+1;
        }
    }
    if(t.a[big]!=0)
        t.len=big+1;
    else t.len=big;
    return t;
}
BigNum BigNum::operator-(const BigNum &T)const { //两个大数之间的相减运算
    int i,j,big;
    bool flag;
    BigNum t1,t2;
    if(*this>T) {
        t1=*this;
        t2=T;
        flag=0;
    } else {
        t1=T;
        t2=*this;
        flag=1;
    }
    big=t1.len;
    for(i=0; i<big; i++) {
        if(t1.a[i]<t2.a[i]) {
            j=i+1;
            while(t1.a[j]==0)
                j++;
            t1.a[j--]--;
            while(j>i)
                t1.a[j--]+=MAXN;
            t1.a[i]+=MAXN+1-t2.a[i];
        } else t1.a[i]-=t2.a[i];
    }
    t1.len=big;
    while(t1.a[len-1]==0 && t1.len>1) {
        t1.len--;
        big--;
    }
    if(flag)
        t1.a[big-1]=0-t1.a[big-1];
    return t1;
}
BigNum BigNum::operator*(const BigNum &T)const { //两个大数之间的相乘
    BigNum ret;
    int i,j,up;
    int temp,temp1;
    for(i=0; i<len; i++) {
        up=0;
        for(j=0; j<T.len; j++) {
            temp=a[i]*T.a[j]+ret.a[i+j]+up;
            if(temp>MAXN) {
                temp1=temp-temp/(MAXN+1)*(MAXN+1);
                up=temp/(MAXN+1);
                ret.a[i+j]=temp1;
            } else {
                up=0;
                ret.a[i+j]=temp;
            }
        }
        if(up!=0)
            ret.a[i+j]=up;
    }
    ret.len=i+j;
    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--;
    return ret;
}
BigNum BigNum::operator/(const int &b)const { //大数对一个整数进行相除运算
    BigNum ret;
    int i,down=0;
    for(i=len-1; i>=0; i--) {
        ret.a[i]=(a[i]+down*(MAXN+1))/b;
        down=a[i]+down*(MAXN+1)-ret.a[i]*b;
    }
    ret.len=len;
    while(ret.a[ret.len-1]==0 && ret.len>1)
        ret.len--;
    return ret;
}
int BigNum::operator%(const int &b)const { //大数对一个 int类型的变量进行取模
    int i,d=0;
    for(i=len-1; i>=0; i--)
        d=((d*(MAXN+1))%b+a[i])%b;
    return d;
}
BigNum BigNum::operator^(const int &n)const { //大数的n次方运算
    BigNum t,ret(1);
    int i;
    if(n<0)exit(-1);
    if(n==0)return 1;
    if(n==1)return *this;
    int m=n;
    while(m>1) {
        t=*this;
        for(i=1; (i<<1)<=m; i<<=1)
            t=t*t;
        m-=i;
        ret=ret*t;
        if(m==1)ret=ret*(*this);
    }
    return ret;
}
bool BigNum::operator>(const BigNum &T)const { //大数和另一个大数的大小比较
    int ln;
    if(len>T.len)return true;
    else if(len==T.len) {
        ln=len-1;
        while(a[ln]==T.a[ln]&&ln>=0)
            ln--;
        if(ln>=0 && a[ln]>T.a[ln])
            return true;
        else
            return false;
    } else
        return false;
}

bool BigNum::operator>(const int &t)const { //大数和一个int类型的变量的大小比较
    BigNum b(t);
    return *this>b;
}
void BigNum::print() { //输出大数
    int i;
    printf("%d",a[len-1]);
    for(i=len-2; i>=0; i--)
        printf("%04d",a[i]);
    printf("\n");
}

typedef struct {
    int pos;
    int val;
} Num;

Num A[N];
BigNum dp[N][N], c[N];

void Init(int n)
{
    for(int i = 1; i <= n; i++) {
        dp[i][1] = 1;
        for(int j = 2; j <= i; j++) {
            dp[i][j] = 0;
        }
    }
}

int Lowbit(int x)
{
    return x & (-x);
}

void Add(int x, BigNum val, int n)
{
    while(x <= n) {
        c[x] = c[x] + val;
        x += Lowbit(x);
    }
}

BigNum Sum(int x)
{
    BigNum sum = 0;
    while(x > 0) {
        sum = sum + c[x];
        x -= Lowbit(x);
    }
    return sum;
}

bool cmp(Num a, Num b)
{
    if(a.val == b.val) return a.pos > b.pos;
    else return a.val < b.val;
}

int main()
{
    int n, k;

    while(scanf("%d %d", &n, &k) != EOF) {
        Init(n);
        for(int i = 1; i <= n; i++) {
            scanf("%d", &A[i].val);
            A[i].pos = i;
        }
        sort(A+1, A+n+1, cmp);
        for(int i = 2; i <= k; i++) {
            for(int j = 0; j <= n; j++) {
                c[j] = 0;
            }
            for(int j = 1; j <= n; j++) {
                Add(A[j].pos, dp[j][i-1], n);
                dp[j][i] = dp[j][i] + Sum(A[j].pos - 1);
            }
        }
        BigNum ans = 0;
        for(int i = k; i <= n; i++) {
            ans = ans + dp[i][k];
        }
        ans.print();
    }

    return 0;
}
View Code

 

 

 

 

 

 

HDU 5568 - BestCoder Round #63 - sequence2

标签：

原文地址：http://www.cnblogs.com/Quinte/p/4986422.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！