PAT-B

1003：分析题目要求就会发现，是要求出P之前的A个数、PT中间的A个数、T之后的A个数，以及它们之间的关系，依次来判断Yes or No，因此解题前要多分析题目题意。C语言实现：https://www.cnblogs.com/EasonDongH/p/9571917.html

1015：主要是对Compare函数的各种情况考虑周全。

1020：用到贪心策略，即优先卖最贵的月饼，然后卖次贵的月饼，以此类推。C语言实现：https://www.cnblogs.com/EasonDongH/p/9571981.html

1025：翻转链表，链表操作的基本技能。

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 100001
#define Null -1

typedef int ElementType;
typedef struct LNode *PtrToNode;
struct LNode{
  ElementType Data;
  int Address, Next;
};
typedef PtrToNode List;

int ReverseK(List *list, int head, int k){
  int cnt=0, p2, tmp1, tmp2;
  
  tmp1 = Null;
  p2 = head;
  tmp2 = list[p2]->Next;
  while( cnt < k ){
    cnt++;
    list[p2]->Next = tmp1;
    tmp1 = p2;
    p2 = tmp2;
    if( tmp2 != Null )
      tmp2 = list[tmp2]->Next;
  }
  
  list[head]->Next = p2;
  return tmp1;
}

int GetLength(List *list, int head){
  int cnt=0;
  
  while( head != Null ){
    cnt++;
    head = list[head]->Next;
  }
  
  return cnt;
}

int ReverseEveryK(List *list, int head, int k){
  if( k == 1 || head == -1 )
    return head;
    
  int cnt=0, length, p1, p2, p3;
  
  length = GetLength( list, head);
  
  p1 = MAXSIZE-1;
  list[p1] = (List)malloc(sizeof(struct LNode));
  list[p1]->Next = head;
  p2 = head;
  while( length >= k ){
    p3 = ReverseK( list, p2, k);
    list[p1]->Next = p3;
    p1 = p2;
    p2 = list[p2]->Next;
    
    length -= k;
  }
  
  return list[MAXSIZE-1]->Next;
}

void Print(List *list, int head){
  while( head != Null ){
      if( list[head]->Next != Null )
      printf("%05d %d %05d\n", list[head]->Address, list[head]->Data, list[head]->Next);
    else
      printf("%05d %d -1\n", list[head]->Address, list[head]->Data);
    head = list[head]->Next;
  }
}

int main(void){
  int i, address, next, head, N, K;
  ElementType data;
  List list[MAXSIZE];
  
  scanf("%d %d %d", &head, &N, &K);
  for( i=0; i<N; i++){
    scanf("%d %d %d", &address, &data, &next);
    list[address] = malloc(sizeof(struct LNode));
    list[address]->Address = address;
    list[address]->Data = data;
    list[address]->Next = next;
  }
  
  head = ReverseEveryK( list, head, K);
//  head = ReverseK( list, head, 5);
  Print( list, head);
  
  return 0;
}

1027:  测试点2未过：当N<=6时，仅需输出一个符号；我输出了3个。

1028：测试3未过：当有效数据为0时，记得输出0，且末尾不能有空格；我有空格。

1030：动态规划，递归Timeout；时间截止时还有测试点4未过，超时。C语言实现：https://www.cnblogs.com/EasonDongH/p/9530864.html

1031: 题意理解问题：对前17位数字加权求和，是指将该位的那个数与该位对应的权值相乘，将前17位的乘积求和，再对11求模得Z.

Z += (ID[i]-'0')*right[i];

1035: 判断插入与归并，并写出下一步排序结果；问题卡在归并排序中，每K个已有序，中的K值求解。得到K之后再随意调用一种算法将数列中每K*2个序列进行排序即可。

int GetLength(int sorted[], int N){
    int i, l, flag;
    
    for( l=2; l<=N; l*=2){
        flag = 1;
        for( i=l; i<N; i+=2*l){
            if( sorted[i] < sorted[i-1] ){
                flag = 0;
                break;
            }
        }
        if( !flag )
          break;
    }
    return l;
}

void merge_sort_once(int* A, int N, int sorted_num){
    int i=0, k, tmp, flag;
    
    k = 2*GetLength( A, N);
    
  while( i < N ){
    if( i + k < N )
         tmp = k;
    else
         tmp = N - i;
         
    sort( A+i, tmp);
    i += tmp;
    }
}

1040：测试4没过，求余运算相当于while（N>=mod）N-=mod，不能使用if；且为什么很多大数都要对1000000007 求余？解答。C语言实现：https://www.cnblogs.com/EasonDongH/p/9538960.html

1045：改进多层循环为迭代，避免超时。C语言实现：https://www.cnblogs.com/EasonDongH/p/9542116.html

1048: 数字加密，一直有两个测试项过不去；原因：当需要加密的整数位数不足加密key时，要在该需加密的数前补零，即最后结果位数一定是与加密key位数一致的，这是个坑，没想到！

1051: 复数乘法，很简单的题，但是再次挂在对精度0的判断上，第二次了（上一次），引以为戒！0.01这个值根据精度要求而来，题目要求是两位数。

if( R+0.01>=0 && R<0 )

 1067：测试项2一直不过，考试时间过了也没解决，之后测试发现：

scanf("%s %d\n", &passWord, &N);

一开始这样写来过滤结尾的换行符，因为从下一行开始要读取字符串；但测试项2就挂在这里，其他不变，这里改写为：

scanf("%s %d", &passWord, &N);
getchar();

就通过了，暂未想明白。

1068：这道题不难，但是却没能满分，注意点3个：一是虽然题目写的是八个相邻点，但四个边的点也要考虑；二差值要加上绝对值才能作比较；三不光要比较周围的点的差值，也要保证当前点的元素值在输入中的唯一性。且这里一直有个段错误，直到开个大数组才解决，未解。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int All_Color[20000000]={0};

int Find(int Color[][2], int color, int N){
  int i;
  
  for( i=0; i<N; i++)
    if( Color[i][0] == color )
      return i;
  return -1;
}

int main(void){
  int i, j, M, N, TOL, index=0, cnt=0, tmp=0, exit_X, exit_Y;
    
  scanf("%d %d %d", &M, &N, &TOL);
  int A[N][M], Color[N*M][2];
  for( i=0; i<N; i++)
    for( j=0; j<M; j++){
      scanf("%d", &A[i][j]);
      All_Color[A[i][j]]++;
      //为什么一直段错误？
      // tmp = Find( Color, A[i][j], index);
      // if( tmp == -1 ){
      //   Color[index][0] = A[i][j];
      //   Color[index][1] = 1;
      //   index++;
      // }
      // else
      //   Color[tmp][1]++;
    }
      
  for( i=0; i<N; i++){
    for( j=0; j<M; j++){
      // tmp = Find( Color, A[i][j], index);
      // if( tmp >= 0 && Color[tmp][1] > 1 )
      //   continue;
      if( All_Color[A[i][j]] > 1 )
        continue;
      if( i>0 && abs(A[i][j] - A[i-1][j]) <= TOL )//up
        continue;
      if( (i>0&&j<M-1) && abs(A[i][j] - A[i-1][j+1]) <= TOL )//up-right
        continue;
      if( j<M-1 && abs(A[i][j] - A[i][j+1]) <= TOL )//right
        continue;
      if( (i<N-1&&j<M-1) && abs(A[i][j] - A[i+1][j+1]) <= TOL )//down-right
        continue; 
      if( i<N-1 && abs(A[i][j] - A[i+1][j]) <= TOL )//down
        continue; 
      if( (i<N-1&&j>0) && abs(A[i][j] - A[i+1][j-1]) <= TOL )//down-left
        continue;
      if( j>0 && abs(A[i][j] - A[i][j-1]) <= TOL )//left
        continue;
      if( (i<N-1&&j>0) && abs(A[i][j] - A[i-1][j-1]) <= TOL )//up-left
        continue;
      
      exit_X = j; exit_Y = i;
      cnt++;
      if( cnt > 1 )
        break;
    }
    if( cnt > 1 )
      break;
  }  
  if( cnt == 0 )
    printf("Not Exist\n");
  else{
    if( cnt == 1 )
      printf("(%d, %d): %d\n", exit_X+1, exit_Y+1, A[exit_Y][exit_X]);
    else
      printf("Not Unique\n");
  }
  
  return 0;
}

1080: 逻辑判断，结合了排序、查找。刚开始最后一个测试项一直过不了，分析代码会发现在根据姓名查找学生的时候比较耗时，最坏O(n²)，一般这种最后一题平方数量级都是不能接受的。改良是一开始用的hashing，结果还是超时，可能是我用的线性探测比较耗时吧；该用二分查找，就过了。C语言代码实现：https://www.cnblogs.com/EasonDongH/p/9578759.html

1085: 排序前先要保证分数的数据类型为int比较才能对。