HDU 4747 Mex

最新推荐文章于 2020-11-23 07:07:02 发布
最新推荐文章于 2020-11-23 07:07:02 发布
阅读量1k 收藏
点赞数 1
CC 4.0 BY-SA版权
分类专栏： HDU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yongxingao/article/details/12841677

Mex

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others)
Total Submission(s): 1414    Accepted Submission(s): 464

Problem Description
Mex is a function on a set of integers, which is universally used for impartial game theorem. For a non-negative integer set S, mex(S) is defined as the least non-negative integer which is not appeared in S. Now our problem is about mex function on a sequence.

Consider a sequence of non-negative integers {ai}, we define mex(L,R) as the least non-negative integer which is not appeared in the continuous subsequence from aL to aR, inclusive. Now we want to calculate the sum of mex(L,R) for all 1 <= L <= R <= n.
 

Input
The input contains at most 20 test cases.
For each test case, the first line contains one integer n, denoting the length of sequence.
The next line contains n non-integers separated by space, denoting the sequence.
(1 <= n <= 200000, 0 <= ai <= 10^9)
The input ends with n = 0.
 

Output
For each test case, output one line containing a integer denoting the answer.
 

Sample Input 
  

   3
0 1 3
5
1 0 2 0 1
0
 

Sample Output 
  

   5
24

   

    

     Hint
    

For the first test case:
mex(1,1)=1, mex(1,2)=2, mex(1,3)=2, mex(2,2)=0, mex(2,3)=0,mex(3,3)=0.
 1 + 2 + 2 + 0 +0 +0 = 5.
 

Source
2013 ACM/ICPC Asia Regional Hangzhou Online
 

Recommend
liuyiding
   
        这题真是做了很长时间啊，但是还是没有过，代码已经出来了，自几测试了上百组数据都过了，交上去就是wa，求数据啊，求数据，求数据，急切的求数据。
终于发现错误了，其实三四天前的代码，只要改一下输出就对了，用long long ,要用cout，否则会错，三四天前的代码如果改成cout<<ans<<endl; 就过了，只不过那时候我怀疑用map映射的时候，映射10^9 ,会出错，就没有向输出考虑，于是就把代码改了，改的时候忽略了一个问题，我把大于200000的没有加到数组中，当时只是以为大于200000的没用，其实还是很有用的，我没仔细想想，就以为他一点用没有，导致这三四天来，反复的改代码都wa。哎，慎重，一定要慎重啊！ 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define N 200010
#define INF 0x7ffffff
using namespace std;
struct num
{
    int l,r;
    __int64 col,Max,sum;
}a[4*N];
int pt[N],b[N],tag[N],pos1,pos2;
int q[N];
int main()
{
    //freopen("data.in","r",stdin);
    //freopen("data1.out","w",stdout);
    void build(int k,int l,int r);
    void del(int k,int val);
    void find(int k,int val);
    void update(int k,int l,int r,int val);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0)
        {
            break;
        }
        int Top=1;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&b[Top]);
            if(b[Top]<=200000)            //错误之处
            {
                Top++;
            }
        }
        n = Top-1;
        if(n==0)
        {
            printf("0\n");
            continue;
        }
        memset(q,0,sizeof(q));
        int res = 0;
        __int64 ans=0;
        for(int i=1;i<=n;i++)
        {
            q[b[i]]=1;
            while(q[res]!=0)
            {
                res++;
            }
            tag[i] = res;
            ans+=(__int64)res;
        }
        memset(pt,0,sizeof(pt));
        memset(q,0,sizeof(q));
        for(int i=1;i<=n;i++)
        {
            int x=b[i];
            if(q[x]!=0)
            {
                pt[q[x]]=i;
            }
            q[x]=i;
        }
        build(1,1,n);
        for(int i=1;i<=n;i++)
        {
            del(1,i);
            pos1 = INF;
            int val=b[i];
            if(a[1].Max<val)
            {
                ans+=a[1].sum;
                continue;
            }
            find(1,val);
            pos2 = pt[i]-1;
            if(pos2 ==-1)
            {
                pos2 = n;
            }
            if(pos1>pos2)
            {
                ans+=a[1].sum;
                continue;
            }
            update(1,pos1,pos2,val);
            ans+=a[1].sum;
        }
      cout<<ans<<endl;
    }
    return 0;
}
void pushup(int k)
{
    a[k].Max = max(a[k<<1].Max,a[k<<1|1].Max);
    a[k].sum = a[k<<1].sum+a[k<<1|1].sum;
    a[k].col= 1;
}
void build(int k,int l,int r)
{
    a[k].l = l;
    a[k].r = r;
    if(l==r)
    {
        a[k].sum = tag[l];
        a[k].Max = tag[l];
        a[k].col = 0;
        return;
    }
    int mid = (l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    pushup(k);
}
void del(int k,int val)
{
    if(a[k].l==a[k].r)
    {
        a[k].col=0;
        a[k].sum=0;
        return ;
    }
    if(a[k].col==0)
    {
        a[k<<1].col=0;
        a[k<<1].Max = a[k].Max;
        a[k<<1].sum = a[k].Max*(__int64)(a[k<<1].r-a[k<<1].l+1);
        a[k<<1|1].col=0;
        a[k<<1|1].Max = a[k].Max;
        a[k<<1|1].sum = a[k].Max*(__int64)(a[k<<1|1].r-a[k<<1|1].l+1);
    }
    int mid = (a[k].l+a[k].r)>>1;
    if(mid>=val)
    {
        del(k<<1,val);
    }else
    {
        del(k<<1|1,val);
    }
    pushup(k);
}
void find(int k,int val)
{
    if(a[k].col==0&&a[k].Max>val)
    {
        pos1 = a[k].l;
        return ;
    }
    if(a[k].col==0)
    {
        return;
    }
    if(a[k].l==a[k].r&&a[k].Max>val)
    {
        pos1 = a[k].l;
        return ;
    }
    if(a[k<<1].Max>val)
    {
        find(k<<1,val);
    }else if(a[k<<1|1].Max>val)
    {
        find(k<<1|1,val);
    }
}
void update(int k,int l,int r,int val)
{
    if(a[k].l==l&&a[k].r==r)
    {
        a[k].Max = val;
        a[k].sum = (__int64)(a[k].r -a[k].l + 1)*(__int64)val;
        a[k].col=0;
        return ;
    }
    if(a[k].col==0)
    {
        a[k<<1].col=0;
        a[k<<1].Max = a[k].Max;
        a[k<<1].sum = a[k].Max*(__int64)(a[k<<1].r-a[k<<1].l+1);
        a[k<<1|1].col=0;
        a[k<<1|1].Max = a[k].Max;
        a[k<<1|1].sum = a[k].Max*(__int64)(a[k<<1|1].r-a[k<<1|1].l+1);
    }
    int mid = (a[k].l+a[k].r)>>1;
    if(r<=mid)
    {
        update(k<<1,l,r,val);
    }else if(l>mid)
    {
        update(k<<1|1,l,r,val);
    }else
    {
        update(k<<1,l,mid,val);
        update(k<<1|1,mid+1,r,val);
    }
    pushup(k);
}
AC的代码： 
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#define N 200010
#define INF 0x7ffffff
using namespace std;
struct num
{
    int l,r;
    __int64 col,Max,sum;
}a[4*N];
int pt[N],b[N],tag[N],pos1,pos2;
int q[N];
int main()
{
    //freopen("data.in","r",stdin);
    //freopen("data1.out","w",stdout);
    void build(int k,int l,int r);
    void del(int k,int val);
    void find(int k,int val);
    void update(int k,int l,int r,int val);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0)
        {
            break;
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&b[i]);
        }
        memset(q,0,sizeof(q));
        int res = 0;
        __int64 ans=0;
        for(int i=1;i<=n;i++)
        {
            if(b[i]<=200000)
            {
                q[b[i]]=1;
            }
            while(q[res]!=0)
            {
                res++;
            }
            tag[i] = res;
            ans+=(__int64)res;
        }
        memset(pt,0,sizeof(pt));
        memset(q,0,sizeof(q));
        for(int i=1;i<=n;i++)
        {
            int x=b[i];
            if(x>200000)
            {
                continue;
            }
            if(q[x]!=0)
            {
                pt[q[x]]=i;
            }
            q[x]=i;
        }
        build(1,1,n);
        for(int i=1;i<=n;i++)
        {
            del(1,i);
            pos1 = INF;
            int val=b[i];
            if(a[1].Max<val)
            {
                ans+=a[1].sum;
                continue;
            }
            find(1,val);
            pos2 = pt[i]-1;
            if(pos2 ==-1)
            {
                pos2 = n;
            }
            if(pos1>pos2)
            {
                ans+=a[1].sum;
                continue;
            }
            update(1,pos1,pos2,val);
            ans+=a[1].sum;
        }
      cout<<ans<<endl;
    }
    return 0;
}
void pushup(int k)
{
    a[k].Max = max(a[k<<1].Max,a[k<<1|1].Max);
    a[k].sum = a[k<<1].sum+a[k<<1|1].sum;
    a[k].col= 1;
}
void build(int k,int l,int r)
{
    a[k].l = l;
    a[k].r = r;
    if(l==r)
    {
        a[k].sum = tag[l];
        a[k].Max = tag[l];
        a[k].col = 0;
        return;
    }
    int mid = (l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    pushup(k);
}
void del(int k,int val)
{
    if(a[k].l==a[k].r)
    {
        a[k].col=0;
        a[k].sum=0;
        return ;
    }
    if(a[k].col==0)
    {
        a[k<<1].col=0;
        a[k<<1].Max = a[k].Max;
        a[k<<1].sum = a[k].Max*(__int64)(a[k<<1].r-a[k<<1].l+1);
        a[k<<1|1].col=0;
        a[k<<1|1].Max = a[k].Max;
        a[k<<1|1].sum = a[k].Max*(__int64)(a[k<<1|1].r-a[k<<1|1].l+1);
    }
    int mid = (a[k].l+a[k].r)>>1;
    if(mid>=val)
    {
        del(k<<1,val);
    }else
    {
        del(k<<1|1,val);
    }
    pushup(k);
}
void find(int k,int val)
{
    if(a[k].col==0&&a[k].Max>val)
    {
        pos1 = a[k].l;
        return ;
    }
    if(a[k].col==0)
    {
        return;
    }
    if(a[k].l==a[k].r&&a[k].Max>val)
    {
        pos1 = a[k].l;
        return ;
    }
    if(a[k<<1].Max>val)
    {
        find(k<<1,val);
    }else if(a[k<<1|1].Max>val)
    {
        find(k<<1|1,val);
    }
}
void update(int k,int l,int r,int val)
{
    if(a[k].l==l&&a[k].r==r)
    {
        a[k].Max = val;
        a[k].sum = (__int64)(a[k].r -a[k].l + 1)*(__int64)val;
        a[k].col=0;
        return ;
    }
    if(a[k].col==0)
    {
        a[k<<1].col=0;
        a[k<<1].Max = a[k].Max;
        a[k<<1].sum = a[k].Max*(__int64)(a[k<<1].r-a[k<<1].l+1);
        a[k<<1|1].col=0;
        a[k<<1|1].Max = a[k].Max;
        a[k<<1|1].sum = a[k].Max*(__int64)(a[k<<1|1].r-a[k<<1|1].l+1);
    }
    int mid = (a[k].l+a[k].r)>>1;
    if(r<=mid)
    {
        update(k<<1,l,r,val);
    }else if(l>mid)
    {
        update(k<<1|1,l,r,val);
    }else
    {
        update(k<<1,l,mid,val);
        update(k<<1|1,mid+1,r,val);
    }
    pushup(k);
}

三四天前改后AC的代码： 
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <map>
#define N 200010
using namespace std;
struct num
{
    long long int l,r,color,Max,sum;
}a[5*N];
map<int,int>q;
int pt[N],b[N],tag[N],pos1,pos2;
int main()
{
    //freopen("data.in","r",stdin);
    void build(int k,int l,int r);
    void del(int k,int val);
    void find(int k,int val);
    void update(int k,int l,int r,int val);
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        if(n==0)
        {
            break;
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&b[i]);
        }
        q.clear();
        int res = 0;
        long long int ans=0;
        for(int i=1;i<=n;i++)
        {
            q[b[i]]=1;
            while(q[res]!=0)
            {
                res++;
            }
            tag[i] = res;
            ans+=(long long int)res;
        }
        q.clear();
        memset(pt,0,sizeof(pt));
        for(int i=1;i<=n;i++)
        {
            int x=b[i];
            if(q[x]!=0)
            {
                pt[q[x]]=i;
            }
            q[x]=i;
        }
        build(1,1,n);
        for(int i=1;i<=n;i++)
        {
            del(1,i);
            int val=b[i];
            find(1,val);
            pos2 = pt[i]-1;
            if(pos2 ==-1)
            {
                pos2 = n;
            }
            if(pos1>pos2||a[1].Max<val)
            {
                ans+=a[1].sum;
                continue;
            }
            update(1,pos1,pos2,val);
            ans+=a[1].sum;
        }
       cout<<ans<<endl;
    }
    return 0;
}
void pushup(int k)
{
    a[k].Max = max(a[k<<1].Max,a[k<<1|1].Max);
    a[k].sum = a[k<<1].sum+a[k<<1|1].sum;
    a[k].color = 1;
}
void build(int k,int l,int r)
{
    a[k].l = l;
    a[k].r = r;
    if(l==r)
    {
        a[k].sum = tag[l];
        a[k].Max = tag[l];
        a[k].color = 0;
        return;
    }
    int mid = (l+r)>>1;
    build(k<<1,l,mid);
    build(k<<1|1,mid+1,r);
    pushup(k);
}
void del(int k,int val)
{
    if(a[k].l==a[k].r)
    {
        a[k].color=0;
        a[k].sum=0;
        return ;
    }
    if(a[k].color==0)
    {
        a[k<<1].color=0;
        a[k<<1].Max = a[k].Max;
        a[k<<1].sum = a[k].Max*(long long int)(a[k<<1].r-a[k<<1].l+1);
        a[k<<1|1].color=0;
        a[k<<1|1].Max = a[k].Max;
        a[k<<1|1].sum = a[k].Max*(long long int)(a[k<<1|1].r-a[k<<1|1].l+1);
    }
    int mid = (a[k].l+a[k].r)>>1;
    if(mid>=val)
    {
        del(k<<1,val);
    }else
    {
        del(k<<1|1,val);
    }
    pushup(k);
}
void find(int k,int val)
{
    if(a[k].color==0&&a[k].Max>val)
    {
        pos1 = a[k].l;
        return ;
    }
    if(a[k].color==0)
    {
        return;
    }
    if(a[k].l==a[k].r&&a[k].Max>val)
    {
        pos1 = a[k].l;
        return ;
    }
    if(a[k<<1].Max>val)
    {
        find(k<<1,val);
    }else if(a[k<<1|1].Max>val)
    {
        find(k<<1|1,val);
    }
}
void update(int k,int l,int r,int val)
{
    if(a[k].l==l&&a[k].r==r)
    {
        a[k].Max = val;
        a[k].sum = (a[k].r -a[k].l + 1)*val;
        a[k].color=0;
        return ;
    }
    if(a[k].color==0)
    {
        a[k<<1].color=0;
        a[k<<1].Max = a[k].Max;
        a[k<<1].sum = a[k].Max*(a[k<<1].r-a[k<<1].l+1);
        a[k<<1|1].color=0;
        a[k<<1|1].Max = a[k].Max;
        a[k<<1|1].sum = a[k].Max*(a[k<<1|1].r-a[k<<1|1].l+1);
    }
    int mid = (a[k].l+a[k].r)>>1;
    if(r<=mid)
    {
        update(k<<1,l,r,val);
    }else if(l>mid)
    {
        update(k<<1|1,l,r,val);
    }else
    {
        update(k<<1,l,mid,val);
        update(k<<1|1,mid+1,r,val);
    }
    pushup(k);
}



递推计数-hdu-4747-Mex
cc_again的专栏
09-21 6979
题目链接： http://acm.hdu.edu.cn/showproblem.php?pid=4747 题目大意： 给n个数，求所有区间内没有出现的最小非负整数和。 解题思路： 首先感谢大神博客：http://www.cnblogs.com/xin-hua/p/3325154.html可以解释的太少了。 我再解释一遍。 首先要明白，以i结束的所有区间的值的和记为f[i]肯定不超
HDU 4747 Mex 递推DP/线段树
wineandchord
03-29 309
Mex HDU - 4747 定义 mex(S)\mathrm{mex}(S)mex(S) 为集合 SSS 中未出现的最小非负整数。 给一个非负整数序列 {ai}i=1n\{a_i\}_{i=1}^n{ai​}i=1n​，定义 mex(L,R)\mathrm{mex}(L,R)mex(L,R) 为 aL∼aRa_L\sim a_RaL​∼aR​ 之间未出现的最小非负整数，计算： ∑1≤L≤R≤nm...
hdu-4747-Mex
青竹梦
09-18 2203
绝世好题啊 根据题意可知，sum[1,i](表示从1到i这个区间的mex值)是随着i递增的。 可以根据新加入的数来判断新加的数是多少。 #include #include #include #include using namespace std; #define maxn 200010 int a[maxn]; int pre[maxn]; int ss[maxn]; int main
Mex HDU - 4747(dp)
日月
10-15 407
https://cn.vjudge.net/problem/HDU-4747[题目传送门] 解题方案： 既然想用dp的方法解决这个问题，最容易想到的就是用递推解决，难点就在于如何定义从始到终的状态以及如何由上一个状态推出下一个状态，有时候状态的递推不是一个简单的递推式。 pos[i] 存放的是与i相等的数中最靠右端的数的位置。 full[a[i]] 表示完全覆盖[0, a[i]]中的所有数的区间的...
Mex HDU - 4747（线段树+二分）
starlet_kiss的博客
09-11 392
Mex is a function on a set of integers, which is universally used for impartial game theorem. For a non-negative integer set S, mex(S) is defined as the least non-negative integer which is not appeare...
HDU-4747 Mex
Rayment的博客
08-18 1675
Problem 大意就是，给你一个数列，定义某个函数mex(l,r)表示在数列的第l个和第r个之间没有出现过的最小自然数。要求的就是对于这个数列的∑i≤j≤ni,j=1mex(i,j)∑i,j=1i≤j≤nmex(i,j)\sum_{i,j=1}^{i\leq j\leq n}mex(i,j) hdu链接 Sample Input 3 0 1 3 5 1 0 2 0 1 0 Sa...
HDU 4747 Mex(线段树维护mex)经典
满月照亮的路
08-09 1070
  Mex Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 3851    Accepted Submission(s): 1278   Problem Description Mex is a function on a se...
HDU 4747 Mex（线段树+思维题）
退役的铜牌狗
12-08 942
Problem Description Mex is a function on a set of integers, which is universally used for impartial game theorem. For a non-negative integer set S, mex(S) is defined as the least non-negative integer
HDU 4747 Mex （线段树）
窝不是爱酱,喵~~~~
09-16 9084
转载请注明出处，谢谢http://blog.youkuaiyun.com/ACM_cxlove?viewmode=contents    by---cxlove 题目：给出一个序列，mex{}表示集合中没有出现的最小的自然数。然后 求sigma(mex (i , j)). 比赛的时候，被老大秒了。。。太可怕了。。。 做法：考虑左端点固定时的所有区间的mex值，这个序列是一个非递减了。。。首先要明白。
hdu4747 Mex (线段树 好题)
u010598215的专栏
09-07 729
（这次的代码写得非常的丑，因为敲代码时的环境非常的乱，大家可以不用看了。。。。。。）   题目大意： 给一个数字串。 然后定义一个函数Mex({A}) = A中没有的最小的非负整数。 即若A = {0、1、3}，则Mex(A) = 2 然后要求数字串的所有连续子串的Mex值之和。   总结： 这一题我想了很久。这一题的解放真是太有意思了，处于我思维的一个盲点。 我一开始想过处理
Mex HDU - 4747(递推， 思维)
Sirius_han的博客
04-23 395
Mex 题目链接：HDU - 4747题意： 在一个非负整数集合S中定义mex(L, R)为集合S中L到R区间的最大非负整数；求所有mex(L, R)(1&lt;=L&lt;=R&lt;...
hdu 4747（DP？线性递推）
weixin_30780649的博客
09-04 284
Mex Time Limit: 15000/5000 MS (Java/Others)Memory Limit: 65535/65535 K (Java/Others) Total Submission(s): 3876Accepted Submissi...
Mex-hdu4747（DP）
weixin_30323631的博客
03-01 146
链接：http://acm.hdu.edu.cn/showproblem.php?pid=4747 题目大意：给一个含有n个数的序列 ns[1~n]，定义函数 mex（l，r）为区间 [l，r] 中未出现的最小的非负整数，求序列ns所有区间的 mex 和。 Sample Input 3 0 1 3 5 1 0 2 0 1 0 Sample Output 5 24思路...
[dp] 对hdu4747 Mex 的详解
隙间
04-22 1420
题目连接：http://acm.hdu.edu.cn/showproblem.php?pid=4747题目大意：给一个含有n个数的序列 ns[1~n]定义函数 mex（l，r）为区间 [l，r] 中未出现的最小的非负整数求序列ns所有区间的 mex 和可以表示为：for( l=1 ; l&lt;=n ; l++) for( r=l ; r&lt;=n ; r++) sum += mex( l...
hdu 4747(区间更新)
俯瞰风景
08-31 2152
题意：一个长度为n的序列，然后求任意左右区间l,r中没有出现过的最小的数字的和。 题解：如果固定区间的左端点得到的所有区间的解是从左到右发现是一个递增序列，用线段树维护当前固定左端点的区间的解的和和最大值，然后更新下一个左端点a[i+1]的区间，那么a[i]就要删除，发现以a[i+1]为左端点的区间所有mex值要把之前第一个mex大于a[i]的位置到下一个a[i]的位置所有值设置为a[i]。 举
【比赛回顾】广工大2020级年ACM第一次月赛——K阶Mex数列（刷题生涯最坎坷的一道题）
z
10-21 687
题目： Description 定义a[l,r] = { a[l] , a[l+1] , a[l+2], … a[r-1] , a[r] } 定义mex函数：mex(l,r) = 不存在于a[l,r]内的最小非负整数 定义k阶Mex数列：Mex(n)= n (n<k) mex(n-k,n-1) (n>=k) a[i]=Mex(i) Input 第一行输入一个整数T，表示有T组数据。(1<=T<=100000) 每组数据输入两个整数n,k(0<=n<=1000000000,
acm-(线段树、mex)Codeforces Round #678 (Div. 2) E. Complicated Computations
qq_30361651的博客
11-23 524
传送门 本题不好直接求每个子串的mexmexmex，转化一下思路，对于iii而言，我们不妨检查是否存在一个子串使得mex=imex=imex=i。 现在讨论满足怎样条件的一个子串s[l∼r]s[l\sim r]s[l∼r]的mex=imex=imex=i： s[l∼r]≠is[l\sim r]\ne is[l∼r]​=i 1,2,...,i−1∈s[l∼r]1,2,...,i-1\in s[l\sim r]1,2,...,i−1∈s[l∼r] 于是我们遍历sss数组，以当前位置r+1r+1r+1减去.
hdu4747（求mex区间之和）
blaze_jack
07-24 920
求区间所有mex之和，用线段树会快一秒，但是写的很长，所以我写了递推版的。 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;cstring&gt; #include&lt;cmath&gt; #include&lt;vector&gt; #include&lt;queue...
ACM 数论知识 合集
热门推荐
ACMer的博客
08-06 1万+
关于欧几里得的那些事真是醉了啊，刚才写了两个小时的博文，想保存到草稿箱里，结果显示服务器异常，结果返回一看，卧槽，写的都没了，心中是万千草泥马呼啸而过呀。。。还得从新写呀。欧几里得算法最大公约数问题是最早被研究的算法问题之一了，并且是ACM竞赛中能涉及到的很 多数论内容，比如模线性方程，模线性方程组的基础。欧几里得算法 (Euclidean algorithm) ，即大部分选手所知的“辗转相除法”，
ACM HDU题目分类概要
"该资源是关于ACM竞赛中HDU（杭州电子科技大学在线评测系统）题目的分类，包含了从1001到1087的题目简介，涵盖了各种算法和编程技巧，如搜索、动态规划、贪心、数学、字符串处理等。" 在ACM HDU题目分类中，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值