HDU 6601(2019杭电多校二 1011) Keen On Everything But Triangle（主席树 + 组成三角形相关）

最新推荐文章于 2019-12-21 12:50:38 发布
最新推荐文章于 2019-12-21 12:50:38 发布
阅读量240 收藏
点赞数
分类专栏： 数据结构——主席树 好题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdz20172133/article/details/101515595
版权

 

 

Keen On Everything But Triangle

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Total Submission(s): 4879    Accepted Submission(s): 1182

 

Problem Description

N sticks are arranged in a row, and their lengths are a1,a2,...,aN.

There are Q querys. For i-th of them, you can only use sticks between li-th to ri-th. Please output the maximum circumference of all the triangles that you can make with these sticks, or print −1 denoting no triangles you can make.

 

 

Input

There are multiple test cases.

Each case starts with a line containing two positive integers N,Q(N,Q≤105).

The second line contains N integers, the i-th integer ai(1≤ai≤109) of them showing the length of the i-th stick.

Then follow Q lines. i-th of them contains two integers li,ri(1≤li≤ri≤N), meaning that you can only use sticks between li-th to ri-th.

It is guaranteed that the sum of Ns and the sum of Qs in all test cases are both no larger than 4×105.

 

 

Output

For each test case, output Q lines, each containing an integer denoting the maximum circumference.

 

 

Sample Input

 

5 3 2 5 6 5 2 1 3 2 4 2 5

 

 

Sample Output

 

13 16 16

 

 

Source

2019 Multi-University Training Contest 2

 

 

Recommend

liuyiding   |   We have carefully selected several similar problems for you:  6730 6729 6728 6727 6726 

 

 

OJ题号

HDU - 6601

简单题意

题意：n 根木棍，若干次询问 [l,r] 区间内的木棍能组成的三角形的最大周长。

正解思路

首先，我们需要知道一个定理

这题的最大数为1e9，因为第44斐波那契数列已经查过了，所以我们只需要选出前44k的数就可以了（裸主席树）。然后贪心的考虑区间最大的三个数能否形成三角形，如果不能，考虑区间第 二大、第三大、第四大的三个数，以此类推，直到能形成三角形。

 

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

const int maxn=1e5+7;
const int mod=1e9+7;
int t,n,m,cnt,root[maxn];
LL a[maxn],b[maxn];
//cnt和root：主席树的总点数和每一个根
struct node
{
    int l,r,sum;
} T[maxn*40];
vector<int> v;
int getid(int x)  //离散化
{
    return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
/*
 v.clear();
 sort(v.begin(),v.end());
 v.erase(unique(v.begin(),v.end()),v.end());
*/
//清空，默认给root[0]
int build(int l,int r)
{
    int cur=++cnt;
    T[cur].sum=0;
    if(l==r)
        return cur;
    int mid=l+r>>1;
    build(l,mid);
    build(mid+1,r);
    return cur;
}
///单点修改
void update(int l,int r,int &now,int pre,int pos,int add)
{
    T[++cnt]=T[pre];
    T[cnt].sum+=add;
    now=cnt;
    if(l==r)
        return;
    int mid=(l+r)>>1;
    if(pos<=mid)
        update(l,mid,T[cnt].l,T[pre].l,pos,add);
    else
        update(mid+1,r,T[cnt].r,T[pre].r,pos,add);
}

///查询区间[x，y]第k小，使用v[query(1,n,root[x-1],root[y],mid)-1]
LL query(int l,int r,int x,int y,int k)
{
    if(l==r)
        return l;
    int mid=(l+r)/2;
    int sum=T[T[y].l].sum-T[T[x].l].sum;
    if(sum>=k)
        return query(l,mid,T[x].l,T[y].l,k);
    else
        return query(mid+1,r,T[x].r,T[y].r,k-sum);
}
/*
///查询区间[x，y]<=k的元素个数 query_min(root[x-1],root[y],1,n,k)
int two_find(int x,int y,int k)///二分查找第i小的元素小于等于k的最大元素
//即求k是第几小的元素
{
    int l=0,r=y-x+1;
    while(l<r)
    {
        int mid=(l+r+1)>>1;
        if(v[query(1,n,root[x-1],root[y],mid)-1]<=k)
            l=mid;
        else
            r=mid-1;
    }
    return l;
}
///查询区间[x，y]>=k的最小值 query_min(root[x-1],root[y],1,n,k)
int query_min(int lrot,int rrot,int l,int r,int k)
{
    if(l==r)
    {
        if(T[rrot].sum-T[lrot].sum>0)
            return l;
        else
            return 1e9;
    }
    int mid=(l+r)>>1;
    if(k<=mid)
    {
        int ans=1e9;
        if(k<=l)//这里相当于一个剪枝，在小于l的时候，如果左子树有符合条件的就进入左子树，否则再进入右子树。
        {
            if(T[T[rrot].l].sum-T[T[lrot].l].sum>0)
                ans=min(ans,query_min(T[lrot].l,T[rrot].l,l,mid,k));
            else if(T[T[rrot].r].sum-T[T[lrot].r].sum>0)
                ans=min(ans,query_min(T[lrot].r,T[rrot].r,mid+1,r,k));
            return ans;
        }
        if(T[T[rrot].l].sum-T[T[lrot].l].sum>0) //k在l到mid之间的时候，左右子树都有可能涉及，就左右都看一遍寻找最优解
            ans=min(ans,query_min(T[lrot].l,T[rrot].l,l,mid,k));
        if(T[T[rrot].r].sum-T[T[lrot].r].sum>0)
            ans=min(ans,query_min(T[lrot].r,T[rrot].r,mid+1,r,k));
        return ans;
    }
    else
    {
        int ans=1e9;//k大于mid的时候，直接进入右子树，左子树不用找了
        if(T[T[rrot].r].sum-T[T[lrot].r].sum>0)
            ans=min(ans,query_min(T[lrot].r,T[rrot].r,mid+1,r,k));
        return ans;
    }
}
///查询区间[x,y]的种类个数query_num(1,n,root[y],x)
int query_num(int l,int r,int root,int left)
{
    if(l>=left)
        return T[root].sum;
    int mid=(l+r)>>1;
    if(mid>=left)
        return query_num(l,mid,T[root].l,left)+T[T[root].r].sum;
    else
        return query_num(mid+1,r,T[root].r,left);
}    */
int main()
{


    while(~scanf("%d%d",&n,&m))
    {

        for(int i=1; i<=n; i++)
        {
            scanf("%lld",&a[i]);
            b[i]=a[i];
        }

        sort(b+1,b+n+1);
        int b_n=unique(b+1,b+n+1)-(b+1);
        for(int i=1; i<=n; i++)
        {
            a[i]=lower_bound(b+1,b+b_n+1,a[i])-b;
        }
        cnt=0;
        root[0]=build(1,b_n);
        for(int i=1; i<=n; i++)
        {
            update(1,b_n,root[i],root[i-1],a[i],1);
        }

        while(m--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            int num=r-l+1;
            if(num < 3)
            {
                printf("-1\n");
                continue;
            }
            int k=0;
            LL ans=-1;
            for(int i=num; i>=3; i--)
            {
                LL z=b[query(1,b_n,root[l-1],root[r],i)];
                LL y=b[query(1,b_n,root[l-1],root[r],i-1)];
                LL x=b[query(1,b_n,root[l-1],root[r],i-2)];
                if(y+x>z)
                {
                    ans=x+y+z;
                    break;
                }

            }

            printf("%lld\n",ans);
        }
    }


    return 0 ;
}

 一个比较慢的做法

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;

const int maxn=1e5+7;
const int mod=1e9+7;
int t,n,m,cnt,root[maxn];
LL a[maxn],b[maxn];
//cnt和root：主席树的总点数和每一个根
struct node
{
    int l,r,sum;
} T[maxn*40];
vector<int> v;
int getid(int x)  //离散化
{
    return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
/*
 v.clear();
 sort(v.begin(),v.end());
 v.erase(unique(v.begin(),v.end()),v.end());
*/
//清空，默认给root[0]
int build(int l,int r)
{
    int cur=++cnt;
    T[cur].sum=0;
    if(l==r)
        return cur;
    int mid=l+r>>1;
    build(l,mid);
    build(mid+1,r);
    return cur;
}
///单点修改
void update(int l,int r,int &now,int pre,int pos,int add)
{
    T[++cnt]=T[pre];
    T[cnt].sum+=add;
    now=cnt;
    if(l==r)
        return;
    int mid=(l+r)>>1;
    if(pos<=mid)
        update(l,mid,T[cnt].l,T[pre].l,pos,add);
    else
        update(mid+1,r,T[cnt].r,T[pre].r,pos,add);
}

///查询区间[x，y]第k小，使用v[query(1,n,root[x-1],root[y],mid)-1]
LL query(int l,int r,int x,int y,int k)
{
    if(l==r)
        return l;
    int mid=(l+r)/2;
    int sum=T[T[y].l].sum-T[T[x].l].sum;
    if(sum>=k)
        return query(l,mid,T[x].l,T[y].l,k);
    else
        return query(mid+1,r,T[x].r,T[y].r,k-sum);
}
/*
///查询区间[x，y]<=k的元素个数 query_min(root[x-1],root[y],1,n,k)
int two_find(int x,int y,int k)///二分查找第i小的元素小于等于k的最大元素
//即求k是第几小的元素
{
    int l=0,r=y-x+1;
    while(l<r)
    {
        int mid=(l+r+1)>>1;
        if(v[query(1,n,root[x-1],root[y],mid)-1]<=k)
            l=mid;
        else
            r=mid-1;
    }
    return l;
}
///查询区间[x，y]>=k的最小值 query_min(root[x-1],root[y],1,n,k)
int query_min(int lrot,int rrot,int l,int r,int k)
{
    if(l==r)
    {
        if(T[rrot].sum-T[lrot].sum>0)
            return l;
        else
            return 1e9;
    }
    int mid=(l+r)>>1;
    if(k<=mid)
    {
        int ans=1e9;
        if(k<=l)//这里相当于一个剪枝，在小于l的时候，如果左子树有符合条件的就进入左子树，否则再进入右子树。
        {
            if(T[T[rrot].l].sum-T[T[lrot].l].sum>0)
                ans=min(ans,query_min(T[lrot].l,T[rrot].l,l,mid,k));
            else if(T[T[rrot].r].sum-T[T[lrot].r].sum>0)
                ans=min(ans,query_min(T[lrot].r,T[rrot].r,mid+1,r,k));
            return ans;
        }
        if(T[T[rrot].l].sum-T[T[lrot].l].sum>0) //k在l到mid之间的时候，左右子树都有可能涉及，就左右都看一遍寻找最优解
            ans=min(ans,query_min(T[lrot].l,T[rrot].l,l,mid,k));
        if(T[T[rrot].r].sum-T[T[lrot].r].sum>0)
            ans=min(ans,query_min(T[lrot].r,T[rrot].r,mid+1,r,k));
        return ans;
    }
    else
    {
        int ans=1e9;//k大于mid的时候，直接进入右子树，左子树不用找了
        if(T[T[rrot].r].sum-T[T[lrot].r].sum>0)
            ans=min(ans,query_min(T[lrot].r,T[rrot].r,mid+1,r,k));
        return ans;
    }
}
///查询区间[x,y]的种类个数query_num(1,n,root[y],x)
int query_num(int l,int r,int root,int left)
{
    if(l>=left)
        return T[root].sum;
    int mid=(l+r)>>1;
    if(mid>=left)
        return query_num(l,mid,T[root].l,left)+T[T[root].r].sum;
    else
        return query_num(mid+1,r,T[root].r,left);
}    */
LL res[maxn];

int main()
{


    while(~scanf("%d%d",&n,&m))
    {
    	
        for(int i=1; i<=n; i++)
        {
            scanf("%lld",&a[i]);
            b[i]=a[i];
        }

        sort(b+1,b+n+1);
        int b_n=unique(b+1,b+n+1)-(b+1);
        for(int i=1; i<=n; i++)
        {
            a[i]=lower_bound(b+1,b+b_n+1,a[i])-b;
        }
        cnt=0;
        root[0]=build(1,b_n);
        for(int i=1; i<=n; i++)
        {
            update(1,b_n,root[i],root[i-1],a[i],1);
        }

        while(m--)
        {
            int l,r;
            scanf("%d%d",&l,&r);
            int num=r-l+1;
            if(num < 3)
            {
                printf("-1\n");
                continue;
            }
            int k=0;
            for(int i=1; i<=50; i++)
            {
            	 int j=num-i+1;
            	 if(j<=0) break;
                res[++k]=b[query(1,b_n,root[l-1],root[r],j)];
            }
            LL ans=-1;
            for(int i=1; i<=k-2; i++)
            {
                if(res[i]<res[i+1]+res[i+2])
                {
                    ans=res[i]+res[i+1]+res[i+2];
                    break;
                }
            }
            printf("%lld\n",ans);
        }
    }


    return 0 ;
}

?mid=&wid=51824&sid=&tid=8555&rid=LOADED&custom1=mp.csdn.net&custom2=%2Fpostedit&t=1569550554439?mid=&wid=51824&sid=&tid=8555&rid=FINISHED&custom1=mp.csdn.net&t=1569550554440

pxlsdz
关注
专栏目录
[贪心+斐波那契]算法题
weixin_43889457的博客
07-03 428
题面 小C是一个可爱的女孩，她特别喜欢世界上最稳定的图形：三角形。有一天她得到了n根木棍，她把这些木棍随意的摆放成一行。小K来和小C玩，他发现了这排木棍，突然想知道在一段区间[l,r]之间的木棍（即第L根到第R根木棍）是否可以组成一个三角形，小C表示她不会，所以请你帮忙。 输入 数据只有一组。 第一行只有一个数字N，代表一共有N根木棍，N<=100000。 第二行为N个数，代表每根木棍的长度。每根木棍的大小不超过1e18。 第三行为一个数字Q，代表询问数目，Q<=100000。 接下来的Q行，每
HDU-6601 Keen On Everything But Triangle【2019 Multi-University Training Contest 2】【贪心】【主席树】
weixin_43895356的博客
08-01 111
Keen On Everything But Triangle Time Limit: 6000/3000 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 3718 Accepted Submission(s): 854 Problem Description N sti...
北航2018级算法期末上机部分题解
weixin_42784489的博客
12-21 2317
北航2018级算法期末第二次上机考试部分题解C题 三角形题目描述数据大小输入输出解题思路题解代码 C题 三角形 题目描述 给定 n 根木棍的长度，然后有 q 个询问，每一次询问给定 l , r 表示询问从第 l 根木棍到第 r 根木棍中是否存在可以组成三角形的木棍。如果存在输出 Yes ，否则输出 No。 数据大小 多组输入 每组数据第一行两个正整数 N 和 q (N, q ≤ 1e5)。 第二行...
HDU-6601 三角形 主席树 斐波那契数列
TieWay59的博客
07-24 406
给n个边的长度，询问q次，每次询问回答能构成的三角形的最大周长。 n和q都是1e51e51e5的范围。 先想想如果就给一个数组求最大周长三角形的做法。 容易想到就是排个序，从大到小枚举N-2次，每次检查三条边能不能构成三角形，如果不行，那么最大的那条边就没有其他边可以跟他组了，（其他边都更小）。如果遇到了第一个可行的，那么就是最大周长的三角形的三边了。 上面这种算法是O(NlogN)O(Nl...
HDU6601-区间组成三角形的最大周长
H_ang的博客
08-12 243
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6601 题目大意： 给你一个长度为nn的序列，有q个询问，每个询问给你一个区间[l,r]，每次询问问你在区间[l,r]中，能够组成的最大的三角形的周长。 思路： 因为三角形具有两边之和大于第三边的性质，即a+b>c的性质。而倘若有若干个数都符合条件，则倘若我们将不等号改成等号，这就形成了一个斐波那...
hdu6601 2019杭电多校第二场 Keen On Everything But Triangle
binarycopycode
07-26 398
看到可以离线询问区间，瞬间写莫队，后来偷听到学弟说只要记录最大的30个，我思考了一蛤，发现应该是最大的50个，然后继续莫队，结果一直超时，还想了好多办法优化常数，竟然没想到主席树区间求第k大枚举区间最大的50个。。。。卧槽我今天讲课内容才给学弟们讲过主席树啊。。。。 其实最难的想法还是枚举三角形时，对边排序，然后从长到端枚举，假设有 a<=b<=c<=d.如果b+c>d ...
2019杭电多校 HDU 6601 Keen On Everything But Triangle 线段树 或 主席树
还我笑颜
07-24 209
题目链接：https://vjudge.net/problem/HDU-6601 题意：区间组成最大的三角形周长是多少 题解：根据斐波那契的性质，在1e9内最多有47个数就一定能组成三角形，所以线段树维护下区间的前50大的数，然后每次查询的时候用滚动数组更新一下即可，当然也可以用主席树写，先离散化，记录下每个数的数目，查询前50大即可 #include <bits/stdc++.h&...
杭电多校HDU 6601 Keen On Everything But Triangle（主席树）题解
weixin_30369087的博客
07-26 61
题意： 有\(n\)根长度不一的棍子，q次询问，求\([L，R]\)区间的棍子所能组成的周长最长的三角形。棍长\(\in [1, 1e9]\)，n\(\in [1, 1e5]\)。 思路： 由于不构成三角形的数组为菲波那切数列，所以当棍数超过44时，长度超过1e9，所以从最大开始数最多不超过45次就能找到构成三角形。所以直接主席树查询区间第k大。复杂度\(O(45 * q * logn)...
杭电2019多校第二场 HDU-6601 Keen On Everything But Triangle（线段树+三角形与斐波那契数列 或主席树（模板））
birdmanqin的博客
07-24 243
链接：http://acm.hdu.edu.cn/showproblem.php?pid=6601、 题意：多组样例。给你一个n和q，接下来一行n个数，加下来q行，每行给出l、r，求区间[l,r]中的数，能组成三角形周长的最大值。不能组成则输出-1。 思路：首先，斐波那契数列中的任意三个数都不能组成三角形。如果若干数中，不能选出三个数组成三角形，那么他们肯定全是斐波那契数。因为斐波那契数列增长...
2019-hdu-multi-（2019杭电多校第二场数据与标程）.zip
08-01
《2019-hdu-multi-（2019杭电多校第二场数据与标程）.zip》是一个专门针对编程竞赛爱好者和ACM（国际大学生程序设计竞赛）参赛者的资源包。这个压缩文件的核心内容是2019年杭州电子科技大学（HDU）主办的多校联合...
HDOJ2019（杭电多校第一场的数据与标程）.zip
08-01
【标题】"HDOJ2019（杭电多校第一场的数据与标程）.zip" 提供的是2019年杭州电子科技大学（HDOJ，杭电在线评测系统）多校联合竞赛的第一场的比赛数据和官方参考解题代码，即“标程”。这类资源对于参加ACM/ICPC...
2019 Multi-University Training Contest 4(2019hdu多校第五场数据与标程）.zip
08-11
【标题】"2019 Multi-University Training Contest 4(2019hdu多校第五场数据与标程）.zip" 提供的是一个编程竞赛的数据集和参考解决方案，源自2019年的一场多所大学联合举办的训练比赛。这样的资源对于参与ACM（国际...
【2019杭电多校第二场1005 = HDU6595】Everything Is Generated In Equal Probability（期望-递推）
Cassie_zkq的博客
07-25 612
题目地址：http://acm.hdu.edu.cn/showproblem.php?pid=6595 题目： 给出一个数n,在【1，n】等概率的选择一个数i，在【1，i】内每次等概率的选择一个数字组成长度为i的序列，这个序列中所有数都在【1，i】内，且两两互不相同（也就是说这个长度为i的序列是1->n的一种排列），以这个长度为i的序列为参数array运行程序： 1.统计array中的...
机械原理课程设计 破碎机.doc
最新发布
09-21
机械原理课程设计 破碎机.doc
电子设计论文施密特触发器电子设计论文施密特触发器
09-21
电子设计论文施密特触发器电子设计论文施密特触发器
电子设计论文往返式流动灯电子设计论文往返式流动灯
09-21
电子设计论文往返式流动灯电子设计论文往返式流动灯
基于深度学习来实现序列到序列.zip
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
美国扩大电动汽车充电基础设施政策（英文）.pdf
09-21
政策背景与动机： 签署法案：2021年11月15日，拜登总统签署了《基础设施投资和就业法案》（IIJA），旨在通过多项措施推动美国电动汽车充电基础设施的扩张。 市场增长：随着电动汽车市场的快速增长，对充电基础设施的需求也日益增加，政府政策成为推动这一发展的关键力量。 电动汽车充电基础： 充电技术：电动汽车充电技术通常分为三级，各级充电速度和功率不同，满足不同场景下的充电需求。 充电站类型：包括公共、私人及工作场所充电站，各自具有不同的访问限制和使用特点。 市场趋势与现状： 市场增长：EV市场增长依赖技术进步、成本降低及充电便利性的提高。 充电站数量：截至2022年10月，美国公共和私人充电站总数超过50,000个，其中93%为公共充电站。 区域差异：充电站分布存在地区差异，部分低收入社区充电基础设施不足。 政策与项目： NEVI公式计划：通过IIJA设立的国家电动汽车基础设施（NEVI）公式计划，为各州提供资金以建设EV充电站。 税收抵免：扩展了替代燃料汽车加油站的税收抵免政策，包括EV充电站，以激励投资者。 联合办公室：DOT和DOE成立联合办公室，负责NEVI计划的实施和监管，确保
博弈问题解析：HDU Online Judge与Poj1067的石子游戏策略
这篇资源主要涉及的是博弈问题的解决方法，特别是关于HDU Online Judge上的几道题目，包括HDU 2516, POJ 1067, HDU 1527, HDU 2177以及HDU 2176。这些题目都是关于石子游戏的，玩家需要在一定的规则下决定如何取石子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值