NOI题库分治算法刷题记录

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/DaD3zZ/article/details/49306131
今天晚自习机房刷题,有一道题最终WA掉两组,极其不爽,晚上回家补完作业欣然搞定它,特意来写篇博文来记录下

(最想吐槽的是这个叫做分治的分类,里面的题目真的需要分治吗。。。)
先来说下分治法
分治法的设计思想是:将一个难以直接解决的大问题,分割成一些规模较小的相同问题,以便各个击破,分而治之。
分治策略是:对于一个规模为n的问题,若该问题可以容易地解决(比如说规模n较小)则直接解决,否则将其分解为k个规模较小的子问题,这些子问题互相独立且与原问题形式相同,递归地解这些子问题,然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。
三、分治法适用的情况

分治法所能解决的问题一般具有以下几个特征:

1) 该问题的规模缩小到一定的程度就可以容易地解决

2) 该问题可以分解为若干个规模较小的相同问题,即该问题具有最优子结构性质。

3) 利用该问题分解出的子问题的解可以合并为该问题的解;

4) 该问题所分解出的各个子问题是相互独立的,即子问题之间不包含公共的子子问题。

第一条特征是绝大多数问题都可以满足的,因为问题的计算复杂性一般是随着问题规模的增加而增加;

第二条特征是应用分治法的前提它也是大多数问题可以满足的,此特征反映了递归思想的应用;、

第三条特征是关键,能否利用分治法完全取决于问题是否具有第三条特征,如果具备了第一条和第二条特征,而不具备第三条特征,则可以考虑用贪心法或动态规划法。

第四条特征涉及到分治法的效率,如果各子问题是不独立的则分治法要做许多不必要的工作,重复地解公共的子问题,此时虽然可用分治法,但一般用动态规划法较好。

依据分治法设计程序时的思维过程

实际上就是类似于数学归纳法,找到解决本问题的求解方程公式,然后根据方程公式设计递归程序。
1、一定是先找到最小问题规模时的求解方法
2、然后考虑随着问题规模增大时的求解方法
3、找到求解的递归函数式后(各种规模或因子),设计递归程序即可。
网上和书上学了下,然而你丫做题基本用不大着,也是令我非常无奈

下面是题目。。。。

一、输出前k大的数
7617:输出前k大的数

总时间限制: 10000ms 单个测试点时间限制: 1000ms 内存限制: 65536kB
描述
给定一个数组,统计前k大的数并且把这k个数从大到小输出。

输入
第一行包含一个整数n,表示数组的大小。n < 100000。
第二行包含n个整数,表示数组的元素,整数之间以一个空格分开。每个整数的绝对值不超过100000000。
第三行包含一个整数k。k < n。
输出
从大到小输出前k大的数,每个数一行。
样例输入
10
4 5 6 9 8 7 1 2 3 0
5
样例输出
9
8
7
6
5
然而此题略蛋疼,表示C++党一个sort轻松+愉快
于是就有代码。。。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[100000]={0};
int main()
{
    int n,m;
    cin>>n;
    for (int i=1;i<=n;i++)
     scanf("%d",&a[i]);
    sort(a+1,a+n+1);
    cin>>m;
    for (int i=n;i>=n-m+1;i--)
     cout<<a[i]<<endl;
     //printf("%d ",&a[i]);
  return 0;
} 

此题不解释
二、区间合并
这个题好像排序也解决了。。。表示我不禁想吐槽了
代码(这个题一开始智商被压制了。。。有点略蠢)

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
struct data{
    int head,tail;
};
data qj[50010]={0};
int cmp(data x,data y)
{
  if (x.head<y.head)
   return 1;
  else
   if (x.head==y.head)
    if (x.tail<=y.tail)
     return 1;
    else
     return 0;
   else
    return 0;   
}

int main()
{
    int n;
    bool f=false;
    int start=0,end=0;//如果可以合并,开头和结尾 
    scanf("%d",&n);
    int i,j;
    for (i=1;i<=n;i++)
     { 
      scanf("%d%d",&qj[i].head,&qj[i].tail);
      end=max(end,qj[i].tail);//表示结尾的取所有区间的结尾的最大值 
     }
    sort(qj+1,qj+n+1,cmp);//按照区间的开头进行排序,从小到大,一样则结尾从小到大排序 
    start=qj[1].head;//表示开头的为最小的那个 
    int h=qj[1].head,t=qj[1].tail;//为下文判断是否可以合并做准备 
    for (i=2;i<=n;i++)
      if (qj[i].head>t)//因为有序,满足这个就不能合并 
       {f=true;break;}
      else
       t=max(t,qj[i].tail); //两个合并后,把当前最大的结尾记录,为以后对比做铺垫 
    if (!f)
     printf("%d %d",start,end);
    else
     printf("no");
 return 0;   
}

三、求排列的逆序数
逆序数,及排列中的逆序对的个数,此处用的归并排序,对归并排序进行一个计数的操作即可实现(终于正常的用了次分治,着实不易啊)

7622:求排列的逆序数

总时间限制: 1000ms 内存限制: 65536kB
描述
在Internet上的搜索引擎经常需要对信息进行比较,比如可以通过某个人对一些事物的排名来估计他(或她)对各种不同信息的兴趣,从而实现个性化的服务。

对于不同的排名结果可以用逆序来评价它们之间的差异。考虑1,2,…,n的排列i1,i2,…,in,如果其中存在j,k,满足 j < k 且 ij > ik, 那么就称(ij,ik)是这个排列的一个逆序。

一个排列含有逆序的个数称为这个排列的逆序数。例如排列 263451 含有8个逆序(2,1),(6,3),(6,4),(6,5),(6,1),(3,1),(4,1),(5,1),因此该排列的逆序数就是8。显然,由1,2,…,n 构成的所有n!个排列中,最小的逆序数是0,对应的排列就是1,2,…,n;最大的逆序数是n(n-1)/2,对应的排列就是n,(n-1),…,2,1。逆序数越大的排列与原始排列的差异度就越大。

现给定1,2,…,n的一个排列,求它的逆序数。

输入
第一行是一个整数n,表示该排列有n个数(n <= 100000)。
第二行是n个不同的正整数,之间以空格隔开,表示该排列。
输出
输出该排列的逆序数。
样例输入
6
2 6 3 4 5 1
样例输出
8
提示
1. 利用二分归并排序算法(分治);
2. 注意结果可能超过int的范围,需要用long long存储。

此处稍提一下归并排序
归并排序的基本思想
将待排序序列R[0…n-1]看成是n个长度为1的有序序列,将相邻的有序表成对归并,得到n/2个长度为2的有序表;将这些有序序列再次归并,得到n/4个长度为4的有序序列;如此反复进行下去,最后得到一个长度为n的有序序列。
综上可知:
归并排序其实要做两件事:
(1)“分解”——将序列每次折半划分。
(2)“合并”——将划分后的序列段两两合并后排序。
这道题在归并时记一个数就可以,具体的可以证明,但就不多提了
代码:

#include<iostream>
#include<cstdio>
using namespace std;
int a[100010]={0},L[100010]={0},R[100010]={0};
long long ans=0;
#define M 1000000000;

void gb(int left,int mid,int right)
{
    int ll=mid-left+1; 
    int lr=right-mid;
     for (int i=1;i<=ll;i++)
      L[i]=a[left+i-1];//此操作方便处理 
     for (int i=1;i<=lr;i++)
      R[i]=a[mid+i];
     L[ll+1]=M;//将最后一个赋给一个极大值,可以当作一个“哨兵”非常的精妙,然而经测试似乎不加这条语句会出错 
     R[lr+1]=M;
     int l=1,r=1;
     for (int i=left; i<=right; i++)
      {
        if (L[l]<=R[r])
         {
          a[i]=L[l];
          l++;
         }
        else
         {
          a[i]=R[r];
          r++;
          ans+=ll-l+1;//求逆序对的唯一多出来的语句 
         }
      }
}

void gbsort(int left,int right)
{
  int mid=(left+right)/2;
  if (left<right)
   {
     gbsort(left,mid);//不断分治 
     gbsort(mid+1,right);
     gb(left,mid,right);
   }    
}

int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1; i<=n; i++)
     scanf("%d",&a[i]);
    gbsort(1,n);
    printf("%lld",ans);
  return 0;
}

四、一元三次方程求解
然而第一眼看到这个题其实我是拒绝的,有想过用求根公式,然而本人数学并不是非常好(当然也不是很差)表示求根公式和数学求法非常神,表示理解还不如二分查找答案多编几行代码快,于是开始二分
PS:此处鸣谢聪哥的数学指引

7891:一元三次方程求解

总时间限制: 1000ms 内存限制: 65536kB
描述
有形如:ax3+bx2+cx+d=0 这样的一个一元三次方程。

给出该方程中各项的系数(a,b,c,d 均为实数),并约定该方程存在三个不同实根(根的范围在-100至100之间),且根与根之差的绝对值>=1。要求由小到大依次在同一行输出这三个实根(根与根之间留有空格),并精确到小数点后2位。

输入
一行,包含四个实数a,b,c,d,相邻两个数之间用单个空格隔开。
输出
一行,包含三个实数,为该方程的三个实根,按从小到大顺序排列,相邻两个数之间用单个空格隔开,精确到小数点后2位。
样例输入
1.0 -5.0 -4.0 20.0
样例输出
-2.00 2.00 5.00
提示
记方程f(x)=0,若存在2个数x1和x2,且x1(此处题目应该是残了。。。)(请无视)
闲话不多说上代码吧,这个题也没什么好扯的。。。

#include<cstdio>
#include<cmath>
using namespace std;
double a,b,c,d;

double f(double x)
{
  return a*x*x*x+b*x*x+c*x+d;   
}

double search(double left,double right)
{
   double mid=(left+right)/2;
    if (right-left<1e-4) return mid;
    else
     {
        if (f(mid)==0) return mid;
        else if (f(left)*f(mid)<0) return search(left,mid);
        else return search(mid,right);
     }
}

int main()
{
    double x1,x2;
    scanf("%lf%lf%lf%lf",&a,&b,&c,&d);
    if (a<0)
     {
        a=-a;b=-b;c=-c;d=-d;
     }
     x1=(-2*b-sqrt(4*b*b-12*a*c))/(a*6);
     x2=(-2*b+sqrt(4*b*b-12*a*c))/(a*6);
     double ans1,ans2,ans3;
     ans1=search(-101,x1);
     ans2=search(x1,x2);
     ans3=search(x2,101);
     printf("%.2f %.2f %.2f",ans1,ans2,ans3);
  return 0;
}

五、统计数字
第一眼看题,以为是随便一个桶排就出来了,后来一看数据范围就呵呵了,不过这个题着实还是不难,然而还没有离散化难呢,那怕个什么啊,水量仅次第一题的存在,排个序,统计个数一波输出,一波带走
然而我蛋神@tyc0520居然一开始不会编,表示莫名奇妙,先跪一发

7909:统计数字

总时间限制: 1000ms 内存限制: 65536kB
描述
某次科研调查时得到了n个自然数,每个数均不超过1500000000(1.5*109)。已知不相同的数不超过10000个,现在需要统计这些自然数各自出现的次数,并按照自然数从小到大的顺序输出统计结果。

输入
包含n+1行:
第一行是整数n,表示自然数的个数;
第2~n+1每行一个自然数。

40%的数据满足:1<=n<=1000;
80%的数据满足:1<=n<=50000;
100%的数据满足:1<=n<=200000,每个数均不超过1500 000 000(1.5*10^9)。
输出
包含m行(m为n个自然数中不相同数的个数),按照自然数从小到大的顺序输出。每行输出两个整数,分别是自然数和该数出现的次数,其间用一个空格隔开。
样例输入
8
2
4
2
4
5
100
2
100
样例输出
2 3
4 2
5 1
100 2
下面是代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int a[200010]={0};
int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++)
     scanf("%d",&a[i]);
    sort(a+1,a+n+1);
    int sum=0;
    for (int i=1;i<=n;i++)
    {
        sum++; 
     if (a[i]==a[i+1])
      continue;
     else
      {
            printf("%d %d\n",a[i],sum);
            sum=0;
      }
    }
  return 0;
} 

好了,时间不早了,洗睡去了,表示前路漫漫,仍须努力啊

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页