热身题

---

1.三角形

• 题目大意：n根棍子，棍子i的长度a_i，选出3根棍子组成周长尽可能长的三角形，输出最大周长，无法组成三角形则输出0
• 限制条件：3≤n≤100，1≤a_i≤10⁶
• 做法1：很自然的可以想到穷举所有的方案，复杂度是O(n³)的，n的限制条件1s足够，这里介绍一种O(nlogn)的做法
• 做法2：将棍子按长度从大到小进行排序，判断长度最长的三根棍子能否构成三角形，如果可以则找到满足要求的解，相加即得到最大周长，如果不能构成三角形，说明最长的棍子不能与其他棍子构成三角形，丢弃它，在剩下的棍子里再进行判断，这样可以把复杂度控制在O(nlogn)+O(n)
• 代码：

  #include <iostream>
  #include <ctime>
  #define random(l,r) (rand()%(r-l+1)+l)
  using namespace std;
  
  int n;
  int * a;
  
  void qsort(int, int);
  void swap(int &, int &);
  
  int main(int argc, char * argv[])
  {
      bool flag = false;
      srand((unsigned)time(NULL));
      cin >> n;
       a = new int[n];
      for (int i=0; i<n; i++)
      {
          cin >> a[i];
      }
      qsort(0,n-1);
      for (int i=0; i<n-2; i++)
      {
          if (a[i]<a[i+1]+a[i+2])
          {
              cout << a[i]+a[i+1]+a[i+2] << endl;
              flag = true;
              break;
          }
      }
      if (!flag) cout << 0 << endl;
  }
  
  void qsort(int l, int r)
  {
      int i=l;
      int j=r;
      int mid=a[random(l,r)];
      do
      {
          while (a[i]>mid) i++;
          while (a[j]<mid) j--;
          if (i<=j) swap(a[i++],a[j--]);
      }
      while (!(i>j));
      if (l<j) qsort(l,j);
      if (i<r) qsort(i,r);
  }
  
  void swap(int &x, int &y)
  {
      int t=x;
      x=y;
      y=t;
  }

---

2.Ants (POJ 1852)

• 原题如下：

Ants

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 24129		Accepted: 9652

Description

An army of ants walk on a horizontal pole of length l cm, each with a constant speed of 1 cm/s. When a walking ant reaches an end of the pole, it immediatelly falls off it. When two ants meet they turn back and start walking in opposite directions. We know the original positions of ants on the pole, unfortunately, we do not know the directions in which the ants are walking. Your task is to compute the earliest and the latest possible times needed for all ants to fall off the pole.

Input

The first line of input contains one integer giving the number of cases that follow. The data for each case start with two integer numbers: the length of the pole (in cm) and n, the number of ants residing on the pole. These two numbers are followed by n integers giving the position of each ant on the pole as the distance measured from the left end of the pole, in no particular order. All input integers are not bigger than 1000000 and they are separated by whitespace.

Output

For each case of input, output two numbers separated by a single space. The first number is the earliest possible time when all ants fall off the pole (if the directions of their walks are chosen appropriately) and the second number is the latest possible such time. 

Sample Input

2
10 3
2 6 7
214 7
11 12 7 13 176 23 191

Sample Output

4 8
38 207

• 题解：
  1. 最短时间很简单，所有蚂蚁往较近的一端走即可，这种情况下也不会发生两只蚂蚁相遇的情况，最短时间就是每只蚂蚁所走最短时间的最大值
  2. 对于最长时间，我们需要考虑两只蚂蚁相遇的情况，而事实上，两只蚂蚁相遇之后各自反向前进与两只蚂蚁相遇之后保持原样交错而过继续前进是等效的，因此可认为每只蚂蚁都是独立运动的，最长时间就是每只蚂蚁往较长一端走的时间的最大值
• 代码：

  #include <iostream>
  
  using namespace std;
  
  template <typename T>
  T minn(T, T);
  
  template int minn<int>(int, int);
  
  template <typename T>
  T maxn(T, T);
  
  template<> int maxn<int>(int, int);
  
  int main(int argc, char * argv[])
  {
      int k;
      for (cin >> k; k>0; k--)
      {
          int l, n;
          cin >> l >> n;
          int * a = new int[n];
          for (int i=0; i<n; i++) cin >> a[i];
          int tmin=0, tmax=0;
          for (int i=0; i<n; i++) 
          {
              tmin=maxn(tmin,minn(a[i],l-a[i]));
              tmax=maxn(tmax,maxn(a[i],l-a[i]));
          }
          cout << tmin << ' ' << tmax << endl;
      }
      return 0;
  }
  
  template <typename T>
  T minn(T x, T y)
  {
      if (x<y) return x;
      return y;
  }
  
  template <typename T>
  T maxn(T x, T y)
  {
      if (x>y) return x;
      return y;
  }
  
  template<> int maxn<int>(int x, int y)
  {
      if (x>y) return x;
      return y;
  }

---

3.增加难度的抽签问题

• 题目大意：检查数组k中是否存在k_a+k_b+k_c+k_d=m,要求将四重循环的穷举算法进行优化，四重循环如下：

  for (int a = 0; a < n; a++) {
      for (int b = 0; b < n; b++) {
          for (int c = 0; c < n; c++) {
              for (int d = 0; d < n; d++){
                  if (k[a]+k[b]+k[c]+k[d] == m) {
                      f = true;
                  }
              }
          }
      }
  }

• 优化1:考虑最内侧关于d的循环，做的事就是检查是否有d使得k_a+k_b+k_c+k_d = m，通过移相，可得k_d = m-k_a-k_b-k_c ,也即是说检查数组k中所有元素，判断是否有m-k_a-k_b-k_c ，于是得到三重循环+二分搜索的O(n³logn)的算法
• 优化2：继续优化1的思路，考虑内侧的两个循环，内测的两个循环是在检查是否有c和d使得k_c+k_d =  m-k_a-k_b ，这种情况下只要预先枚举出k_c+k_d 所得的n²个数字（实际上在去除重复之后n(n+1)/2个数字就够了）并排好序，就可以继续利用二分搜索了，总的时间复杂度是O(n²logn)
• 代码：（就放个二分查找的模板好了，枚举k[c]+k[d]的时候把它放在k[c*n+d]里就好了→_→）

  #include <iostream>
  #define random(l,r) (rand()%(r-l+1)+l)
  
  using namespace std;
  
  int n,m;
  int * k;
  
  bool binary_search(int);
  void qsort(int, int);
  
  int main(int argc, char * argv[])
  {
      cin >> n >> m;
      k = new int[n];
      for (int i=0; i<n; i++)
      {
          cin >> k[i];
      }
      qsort(0,n-1);
      for (int i=0; i<n; i++)
      {
          cout << k[i] << ' '; 
      } 
      cout << endl;
      cout.setf(ios_base::boolalpha);
      cout << binary_search(m) << endl;
  }
  
  bool binary_search(int x)
  {
      int l=0, r=n-1;
      while (l<=r)
      {
          int mid = (l+r)/2;
          if (k[mid]==x) return true;
          else if (k[mid]<x) l=mid+1;
          else r=mid-1;
      }
      return false;
  }
  
  void qsort(int l, int r)
  {
      int i=l, j=r;
      int mid=k[random(l,r)];
      do
      {
          while (k[i]<mid) i++;
          while (k[j]>mid) j--;
          if (i<=j)
          {
              int temp=k[i];
              k[i]=k[j];
              k[j]=temp;
              i++;j--;
          }
      }
      while (i<=j);
      if (i<r) qsort(i,r);
      if (j>l) qsort(l,j);
  }