Out of Sorts II（树状数组/模拟）

                                                Out of Sorts II

                                                                               时间限制: 1 Sec  内存限制: 128 MB
                                                                                          提交: 441  解决: 80
                                                                              [提交] [状态] [讨论版] [命题人:admin]

题目描述

Keeping an eye on long term career possibilities beyond the farm, Bessie the cow has started learning algorithms from various on-line coding websites.
Her favorite algorithm thus far is "bubble sort". Here is Bessie's initial implementation, in cow-code, for sorting an array A of length N.

sorted = false
while (not sorted):
   sorted = true
   moo
   for i = 0 to N-2:
      if A[i+1] < A[i]:
         swap A[i], A[i+1]
         sorted = false
Apparently, the "moo" command in cow-code does nothing more than print out "moo". Strangely, Bessie seems to insist on including it at various points in her code.

After testing her code on several arrays, Bessie learns an interesting observation: while large elements can be pulled to the end of the array very quickly, it can take small elements a very long time to "bubble" to the front of the array (she suspects this is how the algorithm gets its name). In order to try and alleviate this problem, Bessie tries to modify her code so that it scans forward and then backward in each iteration of the main loop, so that both large and small elements have a chance to be pulled long distances in each iteration of the main loop. Her code now looks like this:

sorted = false
while (not sorted):
   sorted = true
   moo
   for i = 0 to N-2:
      if A[i+1] < A[i]:
         swap A[i], A[i+1]
   for i = N-2 downto 0:
      if A[i+1] < A[i]:
         swap A[i], A[i+1]
   for i = 0 to N-2:
      if A[i+1] < A[i]:
         sorted = false
Given an input array, please predict how many times "moo" will be printed by Bessie's modified code.

 

输入

The first line of input contains N (1≤N≤100,000). The next N lines describe A[0]…A[N−1], each being an integer in the range 0…109. Input elements are not guaranteed to be distinct.

 

输出

Print the number of times "moo" is printed.

 

样例输入

5
1
8
5
3
2

 

样例输出

2

 

                                                                                  [提交]  [状态]

题解

要求从双向冒泡排序需要排序多少次可以是序列有序，每一次排序，都会将一个前面的数放到后面，把一个后面的数提到前面，这样我们就可以想一下，先把序列排序，然后对于每个位置的数，看他前面的数有多少个到后面去了（是到最后面以后不会再移动了，如果移动了则不算，所以需要用vis标记一下），求它们的最大值就行了，需要注意的是，如果是有序的序列，需要输出1。

模拟

#include <iostream>
#include <iomanip>
#include <fstream>
#include <sstream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <cctype>
#include <algorithm>
#include <functional>
#include <numeric>
#include <string>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <queue>
#include <deque>
#include <list>
using namespace std;
#define ll long long
#define inf 0x3f3f3f3f
struct node
{
    ll x;
    ll y;
} a[100005];
int vis[100005];
int cmp(node a,node b)
{
    if(a.x!=b.x)
        return a.x<b.x;
 
    return a.y<b.y;
}
int main()
{
    int n;
    ll ans=1;
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%lld",&a[i].x);
        a[i].y=i;
 
    }
    sort(a,a+n+1,cmp);
    ll cnt=0;
    for(int i=1; i<=n; i++)
    {
 
        if(a[i].y>i)
            cnt++;
        if(vis[i])
            cnt--;
        vis[a[i].y]=1;
        ans=max(ans,cnt);
 
 
    }
    printf("%lld\n",ans);
 
    return 0;
}

树状数组

#include<bits/stdc++.h>
#define sl(x) scanf("%lld",&x)
using namespace std;
typedef long long ll;
const int N = 1e5+5;
const ll mod = 1e9+7;
const ll INF = 0x3f3f3f3f;
ll c[N],t[N];
struct node{
    ll num,index;
}p[N];
 
bool cmp(node a,node b)
{
    if(a.num == b.num)
    return a.index < b.index;
     
    return a.num < b.num;
}
 
int lowbit(int k)
{
    return k&(-k);
}
 
void add(int k)//建树标记
{
    while(k < N)
    {
        c[k] += 1;
        k += lowbit(k);
    }
}
 
ll query(int k)//区间求和
{
    ll sum = 0;
    while(k)
    {
        sum += c[k];
        k -= lowbit(k);
    }
    return sum;
}
 
int main()
{
    ll n,i,j,k;
    sl(n);
    for(i = 1;i <= n;i++)
    {
        sl(p[i].num);
        p[i].index = i;
    }
    sort(p+1,p+1+n,cmp);
    ll ans = 1;
    for(i=1;i<=n;i++)//边建树状数组边求结果 
    {
        add(p[i].index); 
        ans = max(ans,i-query(i));  //query(i)前i里标记了的 标记了的表示从前i个还是移动到前i个里面 并没有移动到最后面
        //i-query(i)表示 前i个里面移动到最后面的数量 取最大值即可
    }   
    printf("%lld\n",ans);
}