1，

給定平面上n個OIer和n臺電腦，每個OIer只能水平向右和豎直向下，找到一臺電腦寫代碼，其花費為OIer與電腦之間的曼哈頓距離(|x_i-x_j|+|y_i-y_j|)。

求出使n個OIer均找到自己電腦的最小花費。

輸入輸出格式?Input/output

輸入格式：
輸入第1行有一個整數n，表示點的個數。
接下來有n行，第i行包括兩個用空格隔開的整數x_i,y_i，表示第i個OIer的位置；
接下來有n行，第i行包括兩個用空格隔開的整數x_i,y_i，表示第i臺電腦的位置。
輸出格式：
輸出1個整數，表示最小花費。 輸入輸出樣例?Sample input/output 輸入樣例：
2 1 2 1 3 2 2 2 3 輸出樣例：
2

說明?description

對于樣例，第一個OIer尋找到第一臺電腦，第二個OIer尋找到第二臺電腦。
最小花費為|2-1|+|2-2|+|2-1|+|3-3|=2。

對于30%的數據，保證2≤n≤50；
對于60%的數據，保證2≤n≤10^3；
對于100%的數據，保證2≤n≤5×10^4，0≤x_i≤100000，0≤y_i≤100000。
對于100%的數據，保證一定有解。

可以發現，不管oier與computer的對應順序如何，結果相同。
code:

var i,j,n:longint;
    x1,x2,y1,y2:int64;
    a,b:int64;

begin readln(n);
      x1:=0; y1:=0; 
      x2:=0; y2:=0;
      for i:=1 to n do
          begin readln(a,b);
                x1:=x1+a;
                y1:=y1+b;
          end;
      for i:=1 to n do
          begin readln(a,b);
                x2:=x2+a;
                y2:=y2+b;
          end;
      writeln(abs(x2-x1)+abs(y1-y2));
end.

2，

題目描述?Description

OI教練BG在n天中每天早晨會給wxjlzbcd發一套題，其中包含A_i道題目。如果不做的話，題目會累加到下一天。
wxjlzbcd每天能夠刷掉的題目數量為B_i，BG的題目數量太少，可能不能滿足wxjlzbcd每天刷題的需求，如果題目數量不夠，wxjlzbcd當天就不會刷題，因為空出來的時間他有可能會浪費掉。

但是wxjlzbcd不想天天頹廢，他想知道自己最多能有多少天有題刷。

?輸入輸出格式?Input/output

輸入格式：
輸入第1行為一個整數n，表示天數。
第2行包括n個數字A_i，表示BG n天中每天發的題目數A_i。
第3行包括n個數字B_i，表示wxjlzbcd n天中每天能刷掉的題目數B_i。
輸出格式：
輸出第1行為一個整數ans，表示天數。

輸入輸出樣例?Sample input/output

樣例測試點#1

輸入樣例：?
5

1 4 1 2 3

1 2 3 4 5

輸出樣例：
4

?說明?description

對于40%的數據，保證1≤n≤1000；
對于100%的數據，保證1≤n≤250000，0≤a_i≤10^9，0≤b_i≤10^9。

神奇的貪心：
如果能刷題的話就刷；否則就判斷以前的每天中有沒有需要題數比當前大的，然后還原，取當前的。
用堆維護。。。。。。。。

code：

var n,left,day,total:int64;
    i:longint;
    num:array[1..250000] of int64;
    demand:array[1..250000] of int64;
    heap:array[1..250000] of int64;

procedure go_up(st,j:longint);
          var i,temp:longint;
          begin while (j div 2)>=st do
                      begin i:=j>>1;
                            if demand[heap[j]]>demand[heap[i]]
                               then begin emp:=heap[i];
                                          heap[i]:=heap[j];
                                          heap[j]:=temp;
                                          j:=i;
                                    end
                               else break;
                      end;
          end; 

procedure go_down(i,ed:longint);

          var j,temp:longint;
          begin
 while (i<<1)<=ed do
  begin
   j:=i<<1;
   if demand[heap[j+1]]>demand[heap[j]] then j:=j+1;
   if demand[heap[j]]>demand[heap[i]]
    then
     begin
      temp:=heap[i];
      heap[i]:=heap[j];
      heap[j]:=temp;
      i:=j;
     end
    else
     break;
  end;
end;

begin readln(n);
      for i:=1 to n do
          read(num[i]);
      readln;
      for i:=1 to n do
          read(demand[i]);
      left:=0;
      day:=0;
      total:=0;
      for i:=1 to n do
          begin if left+num[i]>=demand[i]
                   then begin inc(day);
                              left:=left+num[i]-demand[i];
                              inc(total);
                              heap[total]:=i;
                              go_up(1,total);
                        end
                   else begin if demand[heap[1]]>=demand[i]
                                 then begin left:=left+num[i]+demand[heap[1]]-demand[i];
                                            heap[1]:=i;
                                            go_down(1,total);
                                      end
                                 else left:=left+num[i];
                        end;
          end;
      write(day);
end.

3， 題目描述?Description 給出n個正整數，Archon、wxjlzbcd兩個人輪流取任意數量的數，游戲的結束條件是n個數都被取走。
每次取數時，獲得的得分為所取數中的最小值。
假設Archon先取數，Archon和wxjlzbcd的策略都是盡可能使得自己的得分減去對手的得分更大，請求出游戲結束時Archon的得分減去wxjlzbcd的得分為多少。 輸入輸出格式?Input/output 輸入格式：
輸入第1行為一個整數n，表示整數個數。
輸入第2行為給出的n個整數a_i。
輸出格式：
輸出第1行為一個整數ans，表示Archon的得分減去wxjlzbcd的得分。 輸入輸出樣例?Sample input/output 輸入樣例：?
3 1 3 1 輸出樣例：
2

?說明?description

對于樣例，Archon取走第二個數，wxjlzbcd取走第一個和第三個數。答案為3-1=2。
對于30%的數據，1≤n≤10；
對于100%的數據，1≤n≤1000000，1≤a_i≤10^9。

設f[i]為剩最小的i個數時前手與后手的最大差值
此時，假設前手取了j個數{0<=j<=i-1}
         前手的增加得分：init[j]
         后手的增加得分：f[j-1];
f[i]:=max{init[j]-f[j-1]}  (0<=j<=i-1)
f[0]:=1;

要先qsort
{在最外層時，不要用head<=tail
           而是head<tail
}
因為1≤n≤1000000,則要在每一次求值時不斷更新。{prevent TLE}

code:

var n:longint;
    i,j,k:longint;
    f,init:array[0..1000000]of longint;
    max:longint;

procedure qsort(x,y:longint);
          var head,tail,k,temp:longint;
          begin head:=x; tail:=y;
                k:=init[(head+tail) div 2];
                while head<tail do
                      begin while init[head]<k do inc(head);
                            while k<init[tail] do dec(tail);
                            if head<=tail
                               then begin temp:=init[head];
                                          init[head]:=init[tail];
                                          init[tail]:=temp;
                                          inc(head);
                                          dec(tail);
                                    end;
                      end;
                if head<y then qsort(head,y);
                if x<tail then qsort(x,tail);
          end;

begin readln(n);
      for i:=1 to n do
          read(init[i]);
      qsort(1,n);
      f[0]:=0;
      max:=init[1]-f[0];
      for i:=1 to n-1 do
          begin f[i]:=max;
                if max<init[i+1]-f[i]
                   then max:=init[i+1]-f[i];
          end;
      f[n]:=max;
      writeln(f[n]);
end.

轉載于:https://www.cnblogs.com/spiderKK/p/4878347.html

總結

以上是生活随笔為你收集整理的14/10/校内测试{天天考，丧心病狂}的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。