POJ 2299 树状数组

原创 2016年08月29日 19:48:54

第一次自己在题里遇到了离散化,也就是这个东西困了我好久的,离散化一般的处理感觉好多种的写法,但是有好有坏,选择合适的写法写即可。

1.

        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
            p.push_back(a[i]);
        }
       sort(p.begin(),p.end());
        p.erase(unique(p.begin(),p.end()),p.end());//如果要删除相同的元素的话
        for(int i=0;i<p.size();i++)
        {
            mp[p[i]]=i+1;
        }

2.

struct Node
{
    int pos,v;
}num[maxn];

bool cmp(Node a,Node b)
{
    return a.v<b.v;
}

  for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
         num[i].v=a[i];
         num[i].pos=i;
       }
        sort(num+1,num+1+n,cmp);
        for(int i=1;i<=n;i++)
        {
          x[num[i].pos]=i;
        }

个人感觉第一种写法更加好理解,第二种同样是可以的,第一种利用的是map来直接对应元素a[i]和离散数值i,然后第二种通常通过结构体来设立i然后由得原来顺序的pos来对应好元素i。

在这个题里面感觉第一种那么写,不知道为什么就是一直超时。(搞不明白= =)、、望大神路过解答下,不胜感激。。

题目的思路还是简单的, 在树状数组上面数列的第i个数了,比i小的包括i的数据有几个为sum也就是c[i],然后相减为前面的比i大的个数。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<vector>

using namespace std;

const int maxn=500010;
int n,a[maxn],c[maxn],x[maxn];
struct Node
{
    int pos,v;
}num[maxn];

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

int sum(int x)
{
  int ret=0;
  while(x>0)
  {
      ret+=c[x];
      x-=lowbit(x);
  }
  return ret;
}

void adds(int x,int d)
{
    while(x<=n)
    {
        c[x]+=d;
        x+=lowbit(x);
    }
}

bool cmp(Node a,Node b)
{
    return a.v<b.v;
}

int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        if(!n)
            break;
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            num[i].v=a[i];
            num[i].pos=i;

        }
        sort(num+1,num+1+n,cmp);
        for(int i=1;i<=n;i++)
        {
          x[num[i].pos]=i;
        }
        memset(c,0,sizeof(c));
        long long ans=0;
        for(int i=1;i<=n;i++)
        {
            adds(x[i],1);
            ans+=i-sum(x[i]);//数列的第i个数了,比i小的包括i的数据有几个为sum,然后相减为前面的比i大的个数
        }
         printf("%lld\n",ans);

    }
    return 0;
}

还有一种归并排序的写法,也先沾上



#include <iostream>  
#include <cstdio>  
using namespace std;  
  
long long num[500005];  
long long temp[500005];  
int n;  
long long ans;  
  
void merge(int low, int mid, int high)  
{  
    int i = low, j = mid + 1, k = low;  
    while (i <= mid && j <= high)  
    {  
        if (num[i] <= num[j])   
        {  
            temp[k++] = num[i++];  
        }  
        else   
        {  
            ans += j - k ;<span style="white-space:pre">    </span>//统计逆序  
            temp[k++] = num[j++];  
        }  
    }  
    while (i <= mid) temp[k++] = num[i++];  
    while (j <= high) temp[k++] = num[j++];  
    for (i = low; i <= high; ++i)  
    {  
        num[i] = temp[i];  
    }  
}  
  
void mergeSort(int a, int b)  
{  
    if (a < b)  
    {  
        int mid = (a + b) / 2;  
        mergeSort(a, mid);  
        mergeSort(mid + 1, b);  
        merge(a, mid, b);  
    }  
}  
  
  
int main()  
{  
    while (scanf("%d", &n) != EOF && n > 0)  
    {  
        ans = 0;  
        for (int i = 0; i < n; ++i)  
        {  
            scanf("%lld", num + i);  
        }  
        mergeSort(0, n - 1);  
        printf("%lld\n", ans);  
    }  
    return 0;  
}  
来自http://blog.csdn.net/alongela/article/details/8119209点击打开链接



版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

[树状数组]POJ 2299 Ultra-QuickSort

传送门:Ultra-QuickSort Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K T...

POJ:2299 Ultra-QuickSort(归并排序/树状数组)

要移动元素的次数实质就是逆序对数。 这个在入门经典上有详细解释,归并排序一改就ok了。 这里我们首先应该明确一个问题,前后两段内部的元素位置并不影响两个分别来自前后两段元素的逆序性,简单点说,a来...

POJ 2299 树状数组求逆序对

题意 给定一组序列可转换相邻项的序列, 求让它排成非递减的最小操作数 题解 就是求序列逆序对数, 但是序列最大数据较大, 数组开不出来, 所以需要现进行离散化 比如 9, 1, 0, 5...
  • ADjky
  • ADjky
  • 2016-11-18 15:42
  • 130

poj 2299 树状数组(离散化)求逆序数

Ultra-QuickSort 题目链接:点击打开链接 传送门:转载处 给定n个数,要求这些数构成的逆序对的个数。除了用归并排序来求逆序对个数,还可以使用树状数组来求解。 树状数组求解的思...

POJ 2299 Ultra-QuickSort 树状数组

Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 52835 ...

POJ 2299 Ultra-QuickSort(逆序数 树状数组)

Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 45960 ...

POJ 2299 Ultra-QuickSort 【归并排序求逆序数 OR 树状数组求逆序数】

PKU2299 Ultra-QuickSort 【归并排序求逆序数 OR 树状数组求逆序数】

POJ2299 Ultra-QuickSort(逆序数问题,树状数组求解)

Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 47676 ...

树状数组例题(poj2299)

传送门: 树状数组,具体的说是 离散化+树状数组。这也是学习树状数组的第一题. 算法的大体流程就是: 1.先对输入的数组离散化,使得各个元素比较接近,而不是离散的, 2.接着,运用树状数组的标准操作来...

poj2299 Ultra-QuickSort 树状数组 + 离散化

Ultra-QuickSort Time Limit: 7000MS   Memory Limit: 65536K Total Submissions: 56422 ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)