【数论 Day2】基础归纳法题解

最新推荐文章于 2021-08-10 15:20:00 发布

ljc20020730

最新推荐文章于 2021-08-10 15:20:00 发布

阅读量442

点赞数

CC 4.0 BY-SA版权

分类专栏： OIer的专属学术题解

本文链接：https://blog.youkuaiyun.com/ljc20020730/article/details/72846771

OIer的专属学术题解专栏收录该内容

7 篇文章

订阅专栏

题目： http://www.cnblogs.com/ljc20020730/p/6919989.html

1.烧水问题SDOI2008（山东省队选拔）

对于本题，O(n²⁾的贪心算法很好找出，就是让前几杯水都加热到100℃后面进行热传递。

打印出前几项，会发现规律……可以优化到O(n)。或者，也可以无耻地打表……

提醒：令第一杯水需要提高t度，找出第二杯、第三杯……需要提高温度的比例关系，找规律解决。

推倒如下:

设沸腾温度为a

则第一杯温度为a,需要加热t1=a

第二杯可以中和的最高温度为a/2,需要加热t2=a/2

第三杯可以中和的最高温度为t3=(a/4+a)/2=5a/8,需要加热t3=3a/8

第四杯可以中和的最高温度为t4=((a/8+5a/8)/2+a)/2=11a/16,需要加热t4=5/16

则t3/t2=3/4=1-1/4,

t4/t3=5/6=1-1/6

…………………………

继续推导得t(n+1)/t(n)=1-1/2n

根据题目描述及物理常识，我们至多能往当前的杯子里分配(现在花费的总热量/i)的热量，而且一定有办法做到。

所以，实际上第i杯水要花费(上一次花费的热量*(2*i-i)/(2*i))单位热量。

var
  n,i:longint;
  cur,tot:double;
begin
assign(input,'heat.in');
assign(output,'heat.out');
reset(input);
rewrite(output);
  readln(n);
  cur:=420000.00/n;
  tot:=0;  
  for i:=1 to n-1 do begin
    tot:=tot+cur;
    cur:=cur*(2*double(i)-1)/(2*double(i))
  end;
  writeln(tot+cur:0:2);
  close(input);
  close(output);
end.

2.六边形(hexagons.pas/c/cpp)

首先讲一种暴力的方法orz

●暴力: 一圈一圈的加，加到i<a or j<b or k<c。

ans:=7; //红色线为公共点。
i:=2;j:=2;k:=2;
while i<a do begin
  ans:=ans+j+k-1;
  i:=i+1;
end;
while j<b do begin
  ans:=ans+i+k-1;
  j:=j+1;
end;
while k<c do begin
  ans:=ans+i+j-1;
  k:=k+1;
end;
writeln(ans);

接下来讲一种O(1)的算法：

直接ans=a*c+a*b+b*c-c-b-a+1

看到下面看到分成3块的面积和为ac+bc+ab

重叠算一次的a+b+c

重叠算两次的1（交点）

所以ans=ac+bc+ab-(a+b+c)+1=a*c+a*b+b*c-c-b-a+1

程序如下：

var a,b,c:longint;
begin
assign(input,'Hexagons.in');
assign(output,'Hexagons.out');
reset(input);
rewrite(output);
 readln(a,b,c);
 writeln(a*c+a*b+b*c-c-b-a+1);
close(input);
close(output);
end.

3.最大子序和

对于样例的解释图：

输入数据，不需要保存序列，可马上序列前缀和为s[i]。q[i]队列维护选取范围的编号，l,r分别表示队列的首尾指针。

队列放起始点

初始化l=0 r=-1

首出队：i-q[l]>B

尾出队：s[q[r]]>=s[i-a]

入队：inc(r);q[r]:=i-a;

ans:=max(s[i]-s[q[l]],ans);

程序如下：

var l,r,a,b,n,i,t,max:longint;
    s,q:array[0..500000]of longint;
begin
assign(input,'max.in');
assign(output,'max.out');
reset(input);
rewrite(output);
 readln(n,a,b);
 s[0]:=0;
 for i:=1 to n do begin
  read(t);
  s[i]:=s[i-1]+t;
 end;//前缀和
 l:=0; r:=-1;
 max:=-maxlongint;
 for i:=a to n do begin
  if (l<=r)and(i-q[l]>b) then inc(l);//当l在r前面并且当前的长度超过B，出队
  while (l<=r)and(s[i-a]-s[q[r]]<=0) do dec(r);//当l在r的前面并且新加入队列的数为负数，那么得出的答案一定会小于某个数
  inc(r); q[r]:=i-a;//扩充队列
  if s[i]-s[q[l]]>max then max:=s[i]-s[q[l]];//s[i]-s[q[l]]表示 i 到 当前队列起始点这么多数的和
 end;
 writeln(max);//输出
 close(input);
 close(output);
end.

这样就可以使平均时间复杂度降为O(n²)以下，关键就是上面的当l在r的前面并且新加入队列的数为负数，那么得出的答案一定会小于某个数，判掉

4.哥德巴赫矩阵

运用筛法求质数的方法，建立一个布尔数组a[]。

＝s[x2]-s[x1-1])*(s[y2]-s[y1-1])

观察上面的规律(除2以个的质数的增加)编程实现。

复杂度：预处理O(MAXN*√MAXN)，处理s[]为O(N)，查询O(1)。

程序如下：

const maxn=1000000;
var u:array[1..10000000]of boolean;
    s:array[0..10000000]of int64;
    i,m,x1,y1,x2,y2:longint;
    now:int64;
Procedure prime(n:longint);
  var i,j:longint;
begin
  for i:=2 to n do
    if not u[i] then begin
      j:=i+i;
      while j<=n do begin
        u[j]:=true;
        inc(j,i);
      end;
    end;
end;
begin
assign(input,'pmatrix.in');
assign(output,'pmatrix.out');
reset(input);
rewrite(output);
  prime(maxn);
  s[1]:=0; s[2]:=0;
  now:=0;
  for i:=3 to maxn do begin
   if u[i]=false then inc(now);
   s[i]:=now;
  end;
  readln(m);
  for i:=1 to m do begin
  readln(x1,y1,x2,y2);
  writeln((s[x2]-s[x1-1])*(s[y2]-s[y1-1])) ;
  end;
  close(input);
  close(output);
end.