C++博客-ArcTan-文章分类-ACM-数据结构

二维线段树-子矩阵和

wangs — Sun, 30 Dec 2012 13:11:00 GMT

无聊中，写了个二维线段树。

N*N的矩阵里，两种种操作
A x y w，a[x][y]加上w
S x1 y1 x2 y2，(x1,y1)到(x2,y2)这个小矩阵里所有数的和

二维线段树:一维对x二分，每个节点也是一个线段树，对y二分。

struct node{
    int l,r,m;
    int sum;
    int num;
    int pos;//treeX里每个节点的线段树在treeY里的位置
}treeX[maxn*2],treeY[maxn*2][maxn*2];
int N;
int a[maxn][maxn];
int s[maxn][maxn];//s[i][j]表示（1，1）到(i,j)子矩阵的和

void buildY(int cnt,int ll,int rr,int root,int l,int r)
{
    treeY[cnt][root].l = l;
    treeY[cnt][root].r = r;
    treeY[cnt][root].sum = s[rr][r]-s[rr][l-1]-s[ll-1][r]+s[ll-1][l-1];
    if (l<r)
    {
        buildY(cnt,ll,rr,2*root,l,(l+r)/2);
        buildY(cnt,ll,rr,2*root+1,(l+r)/2+1,r);
    }
    return ;
}
void buildX(int cnt,int root,int l,int r)
{
    buildY(cnt,l,r,1,1,N);
    treeX[root].l = l;
    treeX[root].r = r;
    treeX[root].sum = s[r][N]-s[l-1][N];
    treeX[root].pos = cnt;
    if (l<r)
    {
        buildX(cnt+1,2*root,l,(l+r)/2);
        buildX(cnt+2,2*root+1,(l+r)/2+1,r);
    }
    return ;
}
int searchY(int cnt,int root,int l,int r)
{
    if (l<=treeY[cnt][root].l && r>=treeY[cnt][root].r)
        return treeY[cnt][root].sum;
    int sum_l = 0, sum_r = 0;
    int mid = (treeY[cnt][root].r + treeY[cnt][root].l)/2;
    if (l<=mid)
        sum_l = searchY(cnt,2*root,l,r);
    if (r>mid)
        sum_r = searchY(cnt,2*root+1,l,r);
    return sum_l + sum_r;
}
int searchX(int root,int ll,int rr,int l,int r)
{
    if (ll<=treeX[root].l && rr>=treeX[root].r)
        return searchY(treeX[root].pos,1,l,r);
    int sum_l = 0,sum_r = 0;
    int mid = (treeX[root].l+treeX[root].r)/2;
    if (ll<=mid)
        sum_l = searchX(2*root,ll,rr,l,r);
    if (rr>mid)
        sum_r = searchX(2*root+1,ll,rr,l,r);
    return sum_l + sum_r;
}

void addY(int cnt,int root,int y,int w)
{
    treeY[cnt][root].sum += w;
    if (treeY[cnt][root].l ==treeY[cnt][root].r)
        return ;
    int mid = (treeY[cnt][root].l + treeY[cnt][root].r)/2;
   // puts("y");
    if (y<=mid)
        addY(cnt,2*root,y,w);
    else
        addY(cnt,2*root+1,y,w);
    return ;
}
void addX(int root,int x,int y,int w)
{
    treeX[root].sum += w;
    addY(treeX[root].pos,1,y,w);
    if (treeX[root].l == treeX[root].r)
        return ;
   // puts("x");
    int mid = (treeX[root].l+treeX[root].r)/2;
    if (x<=mid)
        addX(2*root,x,y,w);
    else
        addX(2*root+1,x,y,w);
}

C和C++弱啊，该写个模版的。

wangs 2012-12-30 21:11 发表评论

Trie树

wangs — Wed, 22 Aug 2012 01:26:00 GMT

Trie树就是字符树，其核心思想就是空间换时间

举个简单的例子。

给你100000个长度不超过10的单词。对于每一个单词，我们要判断他出没出现过，如果出现了，第一次出现第几个位置。

这题当然可以用hash来，但是我要介绍的是trie树。在某些方面它的用途更大。比如说对于某一个单词，我要询问它的前缀是否出现过。这样hash就不好搞了，而用trie还是很简单。

现在回到例子中，如果我们用最傻的方法，对于每一个单词，我们都要去查找它前面的单词中是否有它。那么这个算法的复杂度就是O(n^2)。显然对于100000的范围难以接受。现在我们换个思路想。假设我要查询的单词是abcd，那么在他前面的单词中，以b，c，d，f之类开头的我显然不必考虑。而只要找以a开头的中是否存在abcd就可以了。同样的，在以a开头中的单词中，我们只要考虑以b作为第二个字母的……这样一个树的模型就渐渐清晰了……

假设有b，abc，abd，bcd，abcd，efg，hii这6个单词，我们构建的树就是这样的。

对于每一个节点，从根遍历到他的过程就是一个单词，如果这个节点被标记为红色，就表示这个单词存在，否则不存在。

那么，对于一个单词，我只要顺着他从跟走到对应的节点，再看这个节点是否被标记为红色就可以知道它是否出现过了。把这个节点标记为红色，就相当于插入了这个单词。

这样一来我们询问和插入可以一起完成，所用时间仅仅为单词长度，在这一个样例，便是10。

我们可以看到，trie树每一层的节点数是26^i级别的。所以为了节省空间。我们用动态链表，或者用数组来模拟动态。空间的花费，不会超过单词数×单词长度。

wangs 2012-08-22 09:26 发表评论

poj 1182食物链(并查集的应用)

wangs — Thu, 26 Jul 2012 13:51:00 GMT

并查集好经典的应用，搞明白这个题目，可以秒杀POJ所有并查集题目!

struct node{
      int father;根节点
      int relation;与根节点关系:0 同类，1吃根节点，2被吃
} line[maxn];

int find(int x)
{
      if (x!=line[x].father)
      {
            int tmp=line[x].father;
            line[x].father=find(tmp);
            //找规律，求出公式
            num[x]=(line[x].relation+line[tmp].relation) % 3;
       }
      returen line[x].father;
}
void union(int x,int y,int d)
{
      int fx=find(x);
      int fy=find(y);
      line[fx].father=fy;
       //找规律，求出公式
      line[fx].relation=(line[y].relation-line[x].relation+2+d) % 3;
      return ;
}

Thinking && Coding！！！

wangs 2012-07-26 21:51 发表评论

并查集基础和的应用

wangs — Thu, 26 Jul 2012 11:28:00 GMT

今天给SDUT的ACMer看了看并查集，总结总结下：
并查集，干的就是“并”和“查”两件事。很多与集合相关的操作都可以用并查集高效的解决。

       int Find(int x)
       {
          if (tree[x].parent != x)
          {
              tree[x].parent = Find(tree[x].parent);
          }
          return tree[x].parent;
       }

       void Merge(int a, int b, int p, int q, int d)
       {
          if (tree[q].depth > tree[p].depth) tree[p].parent = q;
          else
          {
              tree[q].parent = p;
              if (tree[p].depth == tree[q].depth) tree[p].depth++;
          }
       }

其中Find()函数用了路径压缩优化，而Merge()函数用了启发式合并的优化(个人感觉有了路径压缩，启发式合并优化的效果并不明显，而经常因为题目和代码的限制，启发式合并会被我们省略)。

有个问题，如何求节点到跟节点的距离？

wangs 2012-07-26 19:28 发表评论

poj 3468 线段树

wangs — Wed, 25 Jul 2012 02:54:00 GMT

http://poj.org/problem?id=3468

线段数的构造，查询，修改！
struct node{
   int l,r,m;
   long long sum;//当前区间的和
   long long add;//区间需要加上的数值
}

题意：
      给定n个数字A1,A2,..,An，Q个操作。
      C x y z,把区间x y内的数都加上z
      Q x y，求区间x y内所有数的和。
总结：
      基础代码一定要对，调试了半天，最后发现是swap(x,y,t)写错了！！！！
      WA了一次，数据是long long才行，要分析清楚数据范围！！！

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <cassert>
#include <iostream>
#include <sstream>
#include <fstream>
#include <map>
#include <set>
#include <vector>
#include <queue>
#include <algorithm>
#define min(x,y) (x
#define max(x,y) (x>y?x:y)
#define swap(x,y,t) (t=x,x=y,y=t)
#define clr(list) memset(list,0,sizeof(list))
#define LL long long
#define maxn 200005
using namespace std;
struct node{
    int l,r,m;
    LL sum;
    LL add;
} tree[2*maxn];
int a[maxn];
LL build(int l,int r,int root)
{
    tree[root].l=l;
    tree[root].r=r;
    tree[root].m=(l+r)/2;
    tree[root].add=0;
    if (l==r)
    {
        tree[root].sum=a[l];
        return tree[root].sum;
    }
    long long sum_l=build(l,(l+r)/2,root*2);
    long long sum_r=build((l+r)/2+1,r,root*2+1);
    tree[root].sum=sum_l+sum_r;
    return tree[root].sum;
}
int insert(int l,int r,int add,int root)
{
    if (l<=tree[root].l && r>=tree[root].r)
    {
        tree[root].add+=add;
        tree[root].sum+=add * (tree[root].r-tree[root].l+1);
        return 0;
    }
    if (tree[root].add) //向下更新
    {
        tree[2*root].sum+=tree[root].add * (tree[root*2].r-tree[root*2].l+1);
        tree[2*root].add+=tree[root].add;
        tree[2*root+1].sum+=tree[root].add * (tree[root*2+1].r-tree[root*2+1].l+1);
        tree[2*root+1].add+=tree[root].add;
        tree[root].add=0;
    }
    if (l<=tree[root].m)
        insert(l,r,add,root*2);
    if (r>tree[root].m)
        insert(l,r,add,root*2+1);
    tree[root].sum=tree[root*2].sum+tree[root*2+1].sum;   //这里回溯啊
    return 0;
}
LL search(int l,int r,int root)
{
    if (l<=tree[root].l && r>=tree[root].r)
        return tree[root].sum;
    if (tree[root].add)  //向下更新
    {
        tree[2*root].sum+=tree[root].add * (tree[root*2].r-tree[root*2].l+1);
        tree[2*root].add+=tree[root].add;
        tree[2*root+1].sum+=tree[root].add * (tree[root*2+1].r-tree[root*2+1].l+1);
        tree[2*root+1].add+=tree[root].add;
        tree[root].add=0;
    }
    LL sum_l=0,sum_r=0;
    if (l<=tree[root].m)
        sum_l=search(l,r,2*root);
    if (r>tree[root].m)
        sum_r=search(l,r,2*root+1);
    return sum_l+sum_r;
}
int main()
{
    int n,m;
    int x,y,z;
    int tmp;
    char ch;
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    build(1,n,1);

    for (int i=1;i<=m;i++)
    {
        scanf("\n%c",&ch);
        if (ch=='C')
        {
            scanf("%d%d%d",&x,&y,&z);
            if (x>y)
                swap(x,y,tmp);
            insert(x,y,z,1);
        }
        else
        {
            scanf("%d%d",&x,&y);
            if (x>y)
                swap(x,y,tmp);
            printf("%I64d\n",search(x,y,1));
        }
    }
    return 0;
}

wangs 2012-07-25 10:54 发表评论

hdu 2419 (STL：set multiset)

wangs — Sat, 14 Jul 2012 05:08:00 GMT

首先膜拜膜拜青岛二中的 aKc大牛啊，我彻底给跪了！！！
差距太大，好好努力吧！！！

算法，数据结构，C++，STL。需要去学的啊，下午开始学吧学吧

图的操作，使用集合来维护，把操作序列倒过来看，割边则看做两个集合的合并。

STL 的set和multiset 很强大啊，第一用STL写东西

wangs ,你该努力了，大牛之路，远着呢。

#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>
#include <cmath>
#include <climits>

using namespace std;

typedef pair<int, int> PII;
const int MAXN = 20010, MAXM = 60010, MAXQ = 300010;
int value[MAXN], query[MAXQ][3];
multiset<PII> e;
multiset<int> v[MAXN];
int pre[MAXN];

int root(int a)
{
    if(pre[a] != a)
        pre[a] = root(pre[a]);
    return pre[a];
}

int unionSet(int a, int b)
{
    multiset<int>::iterator it;
    a = root(a), b = root(b);
    if(a == b)
        return 0;
    if(v[a].size() > v[b].size())
        swap(a, b);
    for    (it = v[a].begin(); it != v[a].end(); it++)
        v[b].insert(*it);
    v[a].clear();
    pre[a] = b;
    return 0;
}

int update(int a, int x)
{
    int ta = a;
    a = root(a);
    v[a].erase(v[a].find(value[ta]));
    v[a].insert(x);
    value[ta] = x;
    return 0;
}

int main()
{
    int n, m, q;
    int a, b;
    int i,u;
    int cas=0;
    char ch[3];
    double ct = 0, sum = 0;
    multiset<PII>::iterator it;
    multiset<int>::iterator tp;
    while(scanf("%d%d%d",&n,&m,&q)==3)
    {
        e.clear();
        for (i = 1; i <= n; i++)
            v[i].clear();

        for (i = 1; i <= n; i++)
        {
            scanf("%d", &value[i]);
            pre[i] = i;
        }
        for (i = 0; i < m; i++)
        {
            scanf("%d%d", &a, &b);
            if(a > b)
                swap(a, b);
            e.insert(PII(a, b));
        }

        for (i = 0; i < q; i++)
        {
            scanf("%s", &ch);
            scanf("%d%d", &query[i][1], &query[i][2]);

            query[i][0] = ch[0];
            if(ch[0] == 'E')
            {
                if(query[i][1] > query[i][2])
                    swap(query[i][1], query[i][2]);

                it = e.find(PII(query[i][1], query[i][2]));
                e.erase(it);
            }
            else if(ch[0] == 'U')
                swap(value[query[i][1]], query[i][2]);
        }

        for (i = 1; i <= n; i++)
            v[i].insert(value[i]);
        for (it = e.begin(); it != e.end(); it++)
            unionSet(it->first, it->second);

   //     for (it = e.begin(); it != e.end(); it++)
    //        printf("%d %d\n",it->first, it->second);

        ct=0;
        sum=0;

        for(int i = q - 1; i >= 0; i--)
        {
            if(query[i][0] == 'E')
                unionSet(query[i][1], query[i][2]);
            else if(query[i][0] == 'U')
                update(query[i][1], query[i][2]);
            else
            {
                ct += 1;
                u = root(query[i][1]);
                tp = v[u].lower_bound(query[i][2]);
                if(tp != v[u].end())
                    sum += *tp;
          //      printf("%d %d\n",u,*tp);
            }
        }
        printf("Case %d: %0.3lf\n",++cas,(double)sum/ct);
    }
    return 0;
}

wangs 2012-07-14 13:08 发表评论

poj2832(单调队列)----原来就是贪心啊！！！

wangs — Wed, 25 Apr 2012 14:48:00 GMT

：jh辉神说，单调队列单调栈就是贪心嘛，哎哎，怪自己太无知了！！！！

windows,找出区间的最大最小元素，单调队列的经典应用嘛。
应该说，贪心的思想，方法，单调队列是实现的技术才好吧。
poj2832
一次AC，要多理解问题的本质啊！！！

#include<stdio.h>
#include<string.h>
#include<math.h>
int n,k;
int a[1000005],q[1000005];
int main()
{
    int i,head,tail;
    printf("%d\n",(30<<1)*3);
    while (scanf("%d%d",&n,&k)==2)
    {
        for (i=1; i<=n ; i++)
            scanf("%d",&a[i]);
        head=1;
        tail=0;
        memset(q,0,sizeof(q));
        for (i=1; i<=n ; i++ )
        {
            while (head<=tail&&a[q[tail]]>=a[i])
                tail--;
            tail++;
            q[tail]=i;
            while (q[head]<=i-k)
                head++;
            if (i>=k)
                printf("%d ",a[q[head]]);
        }
        printf("\n");
        head=1;
        tail=0;
        memset(q,0,sizeof(q));
        for (i=1; i<=n ; i++ )
        {
            while (head<=tail&&a[q[tail]]<=a[i])
                tail--;
            tail++;
            q[tail]=i;
            while (q[head]<=i-k)
                head++;
            if (i>=k)
                printf("%d ",a[q[head]]);
        }
        printf("\n");
    }
    return 0;
}

额，这个pascal的代码好熟悉啊：

var
  n,k,i,head,tail:longint;
  a,q:array[0..1000001] of longint;

begin
  readln(n,k);
  for i:=1 to n do
    read(a[i]);
  head:=1;tail:=0;
  for i:=1 to n do
    begin
      while (head<=tail) and (a[q[tail]]>=a[i]) do dec(tail);
      inc(tail);
      q[tail]:=i;
      while q[head]<=i-k do inc(head);
      if i>=k then write(a[q[head]],' ');
    end;
  writeln;
  fillchar(q,sizeof(q),0);
  head:=1;tail:=0;
  for i:=1 to n do
    begin
      while (head<=tail) and (a[q[tail]]<=a[i]) do dec(tail);
      inc(tail);
      q[tail]:=i;
      while q[head]<=i-k do inc(head);
      if i>=k then write(a[q[head]],' ');
    end;
  writeln;
end.

居然能没有pascal???

wangs 2012-04-25 22:48 发表评论

poj 2082(单调栈)数学味有点重哦

wangs — Tue, 24 Apr 2012 13:06:00 GMT

poj 2082
这个题目比较坑爹，简单的问题让他给叙述的深奥无比！ＮＰ！！！！数学理解能力当然重要啊！
　　搞清题意后，想到的就是ＤＰ了，感觉有个四边形不等式在里面可以用。。。贪心法应该也是正确的啊，不过一直ＷＡ，也不知道怎么回事。该好好研究研究单调栈，单调队列了。。。。呜呜呜匆
　　ＷＡ了无数次，单调栈一次ＡＣ！

#include<stdio.h>
#include<string.h>
#include<math.h>
int n;
long long stack[50005],pos[50005],sum;
long long ans,w,h;
int main()
{
    int i,top;
    while (scanf("%d",&n)==1&&n!=-1)
    {
        sum=0;top=0;ans=0;
        for (i=1;i<=n ;i++ )
        {
            scanf("%I64d%I64d",&w,&h);

            while (top>0&&h<=stack[top])
            {
                if (ans<(sum-pos[top-1])*stack[top])
                    ans=(sum-pos[top-1])*stack[top];
                top--;
            }
            sum+=w;
            top++;
            stack[top]=h;
            pos[top]=sum;
        }
        while (top>0)
        {
            if (ans<(sum-pos[top-1])*stack[top])
                ans=(sum-pos[top-1])*stack[top];
            top--;
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

wangs 2012-04-24 21:06 发表评论

poj3250(单调栈单调队列)--

wangs — Tue, 24 Apr 2012 12:57:00 GMT

这个题解很好，ＹＭ啊

http://hi.baidu.com/oichampion/blog/item/ed51694a0e1256d9d1c86ae4.html

这个题目ＷＡ了一下午了，哎哎，得研究研究单调栈和单调队列去！
总结：多发现问题的本质。
数学本质！！！

#include<stdio.h>
#include<string.h>
#include<math.h>
long long stack[80008];
int main()
{
    int i,n,top;
    long long x,ans;
    while (scanf("%d",&n)==1)
    {
        top=0;ans=0;
        for (i=1; i<=n ; i++ )
        {
            scanf("%I64d",&x);
            while (top&&x>=stack[top])
                top--;
            ans+=top;
            top++;
            stack[top]=x;
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

wangs 2012-04-24 20:57 发表评论

poj 3494（单调栈-求矩阵面积）数据压缩技巧

wangs — Tue, 24 Apr 2012 09:07:00 GMT

额，今天的意外收获就是单调栈。
还有个单调队列，得看看了：

#include<stdio.h>
#include<string.h>
#include<math.h>
int n,m;
int a[2005],stack[2005],pos[2005],ans;
int GetAns()
{
    int i,top;
    top=0;
    stack[0]=pos[0]=0;
    for (i=1; i<=n ; i++ )
    {
        while (top&&a[i]<=stack[top])
        {
            if (ans<(i-1-pos[top-1])*stack[top])
                ans=(i-1-pos[top-1])*stack[top];
            top--;
        }
        top++;
        stack[top]=a[i];
        pos[top]=i;
    }
    while (top)
    {
        if (ans<(n-pos[top-1])*stack[top])
            ans=(n-pos[top-1])*stack[top];
        top--;
    }
    return 0;
}
int main()
{
    int i,j,x;
    while (scanf("%d%d",&m,&n)==2)
    {
        memset(a,0,sizeof(a));
        ans=0;
        for (i=1; i<=m ; i++ )
        {
            for (j=1; j<=n ; j++ )
            {
                scanf("%d",&x);
                if (x)
                    a[j]++;
                else
                    a[j]=0;
            }
            GetAns();
        }
        printf("%d\n",ans);
    }
    return 0;
}

sdu的段神说的poj3050该看看了，

wangs 2012-04-24 17:07 发表评论

poj 2796(单调栈-连续和最大)

wangs — Tue, 24 Apr 2012 08:53:00 GMT

这个水题又加深了点对单调栈的认识了。不能浅尝辄止！

这个不是special judge么？
总结：以后读题要读清楚，理解明白，不能有歧义啊！

#include<stdio.h>
#include<string.h>
#include<math.h>
int pos[100005],n;
long long stack[100005],sum[100005];
int main()
{
    int i,s,t,top;
    long long a,ans;
    while (scanf("%d",&n)==1)
    {
        top=0;stack[0]=0;pos[0]=0;sum[0]=0;
        ans=0;s=t=0;
        for (i=1;i<=n ;i++ )
        {
            scanf("%I64d",&a);
            sum[i]=sum[i-1]+a;
            while (top&&a<=stack[top])
            {
                if (ans<(sum[i-1]-sum[pos[top-1]])*stack[top])
                {
                    ans=(sum[i-1]-sum[pos[top-1]])*stack[top];
                    s=pos[top-1]+1;t=i-1;
                }
                top--;
            }
            top++;
            stack[top]=a;
            pos[top]=i;
        }
        while (top)
        {
            if (ans<=(sum[n]-sum[pos[top-1]])*stack[top])  //这里是<=才过的，不是special judge么？怎么回事呢，得好好看懂题目啊！
            {
                ans=(sum[n]-sum[pos[top-1]])*stack[top];
                s=pos[top-1]+1;t=n;
            }
            top--;
        }
        printf("%I64d\n%d %d\n",ans,s,t);
    }
    return 0;
}

突然发现自己喜欢写单调栈了，呵呵，这个专题好东西。
感谢sdu的奇奇神提供练习专题！！！ORZ

wangs 2012-04-24 16:53 发表评论

poj1694(单调栈-求矩形最大面积)

wangs — Tue, 24 Apr 2012 07:32:00 GMT

今天就做做单调栈，挺好写的。应该多了解了原理
字符串读入还是有问题啊，这个不行，得看清楚输入后在写！
一次ＡＣ：

#include<stdio.h>
#include<string.h>
#include<math.h>
int n,m,ans;
int a[1005],stack[1005],pos[1005];
int GetAns()
{
    int i,top;
    top=0;
    stack[0]=pos[0]=0;
    for (i=1;i<=n ;i++ )
    {
        while (top>0&&a[i]<=stack[top])
        {
            if (ans<(i-1-pos[top-1])*stack[top])
                ans=(i-1-pos[top-1])*stack[top];
            top--;
        }
        top++;
        stack[top]=a[i];
        pos[top]=i;
    }
    while (top>0)
    {
        if (ans<(n-pos[top-1])*stack[top])
            ans=(n-pos[top-1])*stack[top];
        top--;
    }
}
int main()
{
    int cas,i,j;
    char ch[2];
    scanf("%d",&cas);
    while (cas--)
    {
        memset(a,0,sizeof(a));
        ans=0;
        scanf("%d%d",&m,&n);
        for (i=0;i<m ;i++ )
        {
            for (j=1;j<=n ;j++ )
            {
                scanf("%s",&ch);
                if (ch[0]=='F')
                    a[j]++;
                else
                    a[j]=0;
            }
            GetAns();
        }
        printf("%d\n",3*ans);
    }
    return 0;
}

加油啊，加油！

wangs 2012-04-24 15:32 发表评论

poj 2559 poj 2082(单调栈)

wangs — Tue, 24 Apr 2012 06:53:00 GMT

昨天ACdream群里在讨论单调栈，今天就遇到无数WA，现在也没有没有搞明白单调栈的原理，更没有搞明白我的DP 或者贪心，怎么不对。
单调栈是个好东西，容我去看看啊！
poj 2559
总结：long long类型，要和int区分开来，输出格式用"%I64d"。
数据结构该看看了。
自己多分析分析。
写完一次就AC了，之前的贪心一直都WA呢。囧……

#include<stdio.h>
#include<string.h>
#include<math.h>
int n,pos[100005];
long long stack[100005];
int main()
{
    int i,top;
    long long a,ans;
    while (scanf("%d",&n)==1&&n)
    {
        top=0;ans=0;
        stack[top]=0;pos[top]=0;
        for (i=1 ;i<=n ;i++ )
        {
            scanf("%I64d",&a);
            while (top>0&&a<=stack[top])
            {
                if (ans<(long long)(i-1-pos[top-1])*stack[top])
                    ans=(long long)(i-1-pos[top-1])*stack[top];
                top--;
            }
            top++;
            stack[top]=a;
            pos[top]=i;
        }
        while (top>0)
        {
            if (ans<(long long)(n-pos[top-1])*stack[top])
                ans=(long long)(n-pos[top-1])*stack[top];
            top--;
        }
        printf("%I64d\n",ans);
    }
    return 0;
}

额，要学的东西还很多啊。

wangs 2012-04-24 14:53 发表评论