PTA(浙大数据结构，c语言）

01-复杂度1 最大子列和问题

给定K个整数组成的序列{ N​1​​, N​2​​, ..., N​K​​ }，“连续子列”被定义为{ N​i​​, N​i+1​​, ..., N​j​​ }，其中 1。“最大子列和”则被定义为所有连续子列元素的和中最大者。例如给定序列{ -2, 11, -4, 13, -5, -2 }，其连续子列{ 11, -4, 13 }有最大的和20。现要求你编写程序，计算给定整数序列的最大子列和。

本题旨在测试各种不同的算法在各种数据情况下的表现。各组测试数据特点如下：

数据1：与样例等价，测试基本正确性；

数据2：102个随机整数；

数据3：103个随机整数；

数据4：104个随机整数；

数据5：105个随机整数；

输入格式:

输入第1行给出正整数K (≤)；第2行给出K个整数，其间以空格分隔。

输出格式:

在一行中输出最大子列和。如果序列中所有整数皆为负数，则输出0。

输入样例:

6

-2 11 -4 13 -5 -2

输出样例:

20

#include <stdio.h>

//分而治之
int Max3( int A, int B, int C );
int DivideAndConquer( int List[], int left, int right );
int MaxSubseqSum3( int List[], int N );

int main()
{
    int arr[100000];
    int n;
    scanf("%d",&n);
    for (int i = 0; i < n; ++i)
    {        
        scanf("%d",&arr[i]);
    }
    printf("%d",MaxSubseqSum3(arr, n));
    return 0;
}

int Max3( int A, int B, int C )
{ /* 返回3个整数中的最大值 */
    return A > B ? A > C ? A : C : B > C ? B : C;
}
 
int DivideAndConquer( int List[], int left, int right )
{ /* 分治法求List[left]到List[right]的最大子列和 */
    int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
    int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/
 
    int LeftBorderSum, RightBorderSum;
    int center, i;
 
    if( left == right )  { /* 递归的终止条件，子列只有1个数字 */
        if( List[left] > 0 )  return List[left];
        else return 0;
    }
 
    /* 下面是"分"的过程 */
    center = ( left + right ) / 2; /* 找到中分点 */
    /* 递归求得两边子列的最大和 */
    MaxLeftSum = DivideAndConquer( List, left, center );
    MaxRightSum = DivideAndConquer( List, center+1, right );
 
    /* 下面求跨分界线的最大子列和 */
    MaxLeftBorderSum = 0; LeftBorderSum = 0;
    for( i=center; i>=left; i-- ) { /* 从中线向左扫描 */
        LeftBorderSum += List[i];
        if( LeftBorderSum > MaxLeftBorderSum )
            MaxLeftBorderSum = LeftBorderSum;
    } /* 左边扫描结束 */
 
    MaxRightBorderSum = 0; RightBorderSum = 0;
    for( i=center+1; i<=right; i++ ) { /* 从中线向右扫描 */
        RightBorderSum += List[i];
        if( RightBorderSum > MaxRightBorderSum )
            MaxRightBorderSum = RightBorderSum;
    } /* 右边扫描结束 */
 
    /* 下面返回"治"的结果 */
    return Max3( MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum );
}
 
int MaxSubseqSum3( int List[], int N )
{ /* 保持与前2种算法相同的函数接口 */
    return DivideAndConquer( List, 0, N-1 );
}

#include <stdio.h>

//在线处理
int MaxSubSeqSum(int a[], int k)
{
    int ThisSum, MaxSum;
    ThisSum = MaxSum = 0;
    for(int i=0; i<k; ++i){
        ThisSum += a[i];
        if(ThisSum > MaxSum)
            MaxSum = ThisSum;
        else if(ThisSum < 0)
            ThisSum = 0;
    }
    return MaxSum;
}
int main( ) {
    
    const int N = 100001;
    int a[N];
    int k = 0;
    scanf("%d",&k);
    for(int i=0; i<k; ++i)
        scanf("%d",&a[i]);
    printf("%d
",MaxSubSeqSum(a,k));
    
    return 0;
}

01-复杂度2 Maximum Subsequence Sum

Given a sequence of K integers { N​1​​, N​2​​, ..., N​K​​ }. A continuous subsequence is defined to be { N​i​​, N​i+1​​, ..., N​j​​ } where 1. The Maximum Subsequence is the continuous subsequence which has the largest sum of its elements. For example, given sequence { -2, 11, -4, 13, -5, -2 }, its maximum subsequence is { 11, -4, 13 } with the largest sum being 20.

Now you are supposed to find the largest sum, together with the first and the last numbers of the maximum subsequence.

Input Specification:

Each input file contains one test case. Each case occupies two lines. The first line contains a positive integer K (≤). The second line contains K numbers, separated by a space.

Output Specification:

For each test case, output in one line the largest sum, together with the first and the last numbers of the maximum subsequence. The numbers must be separated by one space, but there must be no extra space at the end of a line. In case that the maximum subsequence is not unique, output the one with the smallest indices i and j (as shown by the sample case). If all the K numbers are negative, then its maximum sum is defined to be 0, and you are supposed to output the first and the last numbers of the whole sequence.

Sample Input:

10

-10 1 2 3 4 -5 -23 3 7 -21

Sample Output:

10 1 4

#include <stdio.h>
#define N 100000
void max_sub_sum(int arr[], int n)
{
    int this_sum = 0, max_sum = -1;
    int first_num, last_num;
    int index_first = 0; //第一个元素下标
    for (int i = 0; i < n; ++i)
    {
        this_sum += arr[i]; 
        if (this_sum > max_sum)//元素全部为负数进不来
        {    //产生最大值,第一个元素,最后一个元素是确定的
            max_sum = this_sum; //最大值
            first_num = arr[index_first];//第一个元素            
            last_num = arr[i];//最后一个元素                
        }
        else if (this_sum < 0)
        {
            this_sum = 0;
            index_first = i+1; //更新第一个元素的下标
        }
    }
    if(max_sum == -1) printf("0 %d %d
", arr[0], arr[n-1]);
    else printf("%d %d %d
", max_sum, first_num, last_num);
}

int main()
{
    int arr[N] = {0};
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &arr[i]);
    }
    max_sub_sum(arr, n);
    return 0;
}

01-复杂度3 二分查找

本题要求实现二分查找算法。

函数接口定义：

Position BinarySearch( List L, ElementType X );

其中List结构定义如下：

typedef int Position;
typedef struct LNode *List;

struct LNode {
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

L是用户传入的一个线性表，其中ElementType元素可以通过>、=、<进行比较，并且题目保证传入的数据是递增有序的。函数BinarySearch要查找X在Data中的位置，即数组下标（注意：元素从下标1开始存储）。找到则返回下标，否则返回一个特殊的失败标记NotFound。

裁判测试程序样例：

#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 10
#define NotFound 0

typedef int ElementType;
typedef int Position;
typedef struct LNode *List;

struct LNode {

    ElementType Data[MAXSIZE];

    Position Last; /* 保存线性表中最后一个元素的位置 */

};

List ReadInput(); /* 裁判实现，细节不表。元素从下标1开始存储 */
Position BinarySearch( List L, ElementType X );

int main()
{
    List L;
    ElementType X;
    Position P;
 
    L = ReadInput();
    scanf("%d", &X);
    P = BinarySearch( L, X );
    printf("%d
", P);
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例1：

5

12 31 55 89 101

31

输出样例1：

2

输入样例2：

3

26 78 233

31

输出样例2：

0

Position BinarySearch( List L, ElementType X )
{
    Position position = NotFound;
    Position left = 1;
    Position right = L->Last;

    while(left <= right){
        Position mid = (left+right)/2;
        if(L->Data[mid] > X){
            right = mid - 1;
        }
        else if(L->Data[mid]<X){
            left = mid + 1;
        }
        else{
            position = mid;
            break;
        }
    }
    return position;
}

02-线性结构1 两个有序链表序列的合并

本题要求实现一个函数，将两个链表表示的递增整数序列合并为一个非递减的整数序列。

函数接口定义：

List Merge( List L1, List L2 );

其中List结构定义如下：

typedef struct Node *PtrToNode;
struct Node {
    ElementType Data; /* 存储结点数据 */
    PtrToNode   Next; /* 指向下一个结点的指针 */
};
typedef PtrToNode List; /* 定义单链表类型 */

L1和L2是给定的带头结点的单链表，其结点存储的数据是递增有序的；函数Merge要将L1和L2合并为一个非递减的整数序列。应直接使用原序列中的结点，返回归并后的带头结点的链表头指针。

裁判测试程序样例：

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

typedef int ElementType;
typedef struct Node *PtrToNode;
struct Node {
    ElementType Data;
    PtrToNode   Next;
};
typedef PtrToNode List;

List Read(); /* 细节在此不表 */
void Print( List L ); /* 细节在此不表；空链表将输出NULL */ 

List Merge( List L1, List L2 );

int main()
{
    List L1, L2, L;
    L1 = Read();
    L2 = Read();
    L = Merge(L1, L2);
    Print(L);
    Print(L1);
    Print(L2);
    return 0;
}

/* 你的代码将被嵌在这里 */

输入样例：

3

1 3 5

5

2 4 6 8 10

输出样例：

1 2 3 4 5 6 8 10

NULL

NULL

List Merge( List L1, List L2 )  
{  
    List pa,pb,pc,L;  //返回L
    L = (List)malloc(sizeof(struct Node));  
    pa=L1->Next;  //传进来的2个带头结点的链表L1,L2
    pb=L2->Next;  
    pc = L;  //新链表头指针赋值
    while(pa && pb)  
    {  
        if(pa->Data <= pb->Data)  
        {  
            pc->Next = pa; //a前插 
            pc = pa;       //更新c指针
            pa = pa->Next; //更新a指针
        }  
        else  
        {  
            pc->Next = pb; //b前插 
            pc = pb;       //更新c指针
            pb = pb->Next; //更新b指针 
        }  
    }  
    pc->Next = pa ? pa : pb;//链接剩余结点  
    L1->Next = NULL;   //按题目要求链表L1,L2置空
    L2->Next = NULL;  
    return L;  
}  

02-线性结构2 一元多项式的乘法与加法运算

设计函数分别求两个一元多项式的乘积与和。

输入格式:

输入分2行，每行分别先给出多项式非零项的个数，再以指数递降方式输入一个多项式非零项系数和指数（绝对值均为不超过1000的整数）。数字间以空格分隔。

输出格式:

输出分2行，分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔，但结尾不能有多余空格。零多项式应输出0 0。

输入样例:

4 3 4 -5 2  6 1  -2 0

3 5 20  -7 4  3 1

输出样例:

15 24 -25 22 30 21 -10 20 -21 8 35 6 -33 5 14 4 -15 3 18 2 -6 1

5 20 -4 4 -5 2 9 1 -2 0

#include <stdio.h>
#include <malloc.h>

//结点
typedef struct Node *List;
struct Node{    
    int coe;  //系数 
    int exp;   //指数 
    List Next;
};

//读入链表 
List Read()
{
    List head = NULL, L = NULL;    
    int n;
    scanf("%d", &n);//n个结点
    
    for(int i=0; i<n; i++)
    {
        List p = (List)malloc(sizeof(struct Node));
        scanf("%d %d", &p->coe, &p->exp);
        p->Next = NULL;  //新结点
        
        if(i == 0) head = L = p; //链表第一个结点
        else{
            L->Next = p; //链入链表
            L = L->Next; //链表指针更新
        }        
    }
    return head; 
}

//加法运算 
List addition(List L1,List L2)
{    
    List head, add;    
    head = add = (List)malloc(sizeof(struct Node));
    head->Next = NULL; //头结点(为了排序调用)
    
    while(L1 && L2)
    {
        List p = (List)malloc(sizeof(struct Node));
        p->Next = NULL;    
        
        if(L1->exp == L2->exp){ //指数相等  
            p->coe = L1->coe + L2->coe; //系数相加
            p->exp = L1->exp; //指数赋值
            L1 = L1->Next; //更新L1
            L2 = L2->Next; //更新L2
        }else if(L1->exp < L2->exp){//L2结点指数大
            p->coe = L2->coe; //L2结点系数赋值
            p->exp = L2->exp; //指数赋值
            L2 = L2->Next;    //更新L2
        }else {             // L1结点指数大
            p->coe = L1->coe; //L1 结点系数赋值
            p->exp = L1->exp; //指数赋值
            L1 = L1->Next;  //更新L1
        }
        
        add->Next = p;
        add = add->Next;        
    }
    if(L1)  // 若L1不等于NULL, 将剩下结点加入其后, 不影响原链表 
        add->Next = L1;
    else if(L2)  // 同理
        add->Next = L2;
    List ret = head->Next;
    free(head);
    return ret; 
}

//乘法运算 
List multiplication(List L1,List L2){
    
    List mul = NULL, head = NULL, tL2 = L2;
    
    for(; L1; L1 = L1->Next)
    {
        for(L2 = tL2; L2; L2 = L2->Next)
        {
            List p = (List)malloc(sizeof(struct Node));
            p->Next = NULL;
            p->coe = L1->coe * L2->coe;  // 系数相乘
            p->exp = L1->exp + L2->exp;  // 指数相加
            if(mul == NULL) head = mul = p;
            else{
                head = addition(p, mul); //结点排序 
                mul = head; // 重新确定开头 
            }                        
        }        
    }
    
    return head;
}

//打印
void Print(List L)
{
    int flag = 1;
    while(L)
    {
        if(!flag && L->coe)//系数不为0
            printf(" ");
        if(L->coe){ //系数为0不输出 
            printf("%d %d",L->coe,L->exp);
            flag =0;        
        }
        L = L->Next;
    }
    if(flag) //空链表
        printf("0 0");
    printf("
");
}

int main()
{
    List L1,L2,add,mul;
    L1 = Read(); //链表L1
    L2 = Read(); //链表L2
    add = addition(L1,L2);
    mul = multiplication(L1,L2);
    Print(mul); //打印乘法结果
    Print(add); //打印加法结果
    return 0;
} 

#include <stdio.h>
#include <malloc.h>
// 结点
typedef struct PolyNode *Polynomial; 
struct PolyNode {  
    int coef;  
    int expon;  
    Polynomial link; 
};
// 0.0
void DestroyPoly(Polynomial* p){
    while(*p)
    {
        Polynomial t = *p;
        *p = (*p)->link;
        free(t);        
    }
}
// 0.1
void Attach( int c, int e, Polynomial *pRear ) 
{    
    Polynomial P; 
    P = (Polynomial)malloc(sizeof(struct PolyNode));    
    P->coef = c;    /* 对新结点赋值  */  
    P->expon = e;  
    P->link = NULL;
    
    (*pRear)->link = P;  /* 新结点插到pRear后面 */  
    *pRear = P; /* 修改pRear值 */ 
} 
// 1.
Polynomial ReadPoly() 
{
    Polynomial  P, Rear, t;      
    int c, e, N; 
    scanf("%d", &N);
    /* 头结点 */ 
    P = Rear = (Polynomial)malloc(sizeof(struct PolyNode));
    Rear->link = NULL;        
    while ( N-- ) 
    {  
        scanf("%d %d", &c, &e);  
        Attach(c, e, &Rear);           
    }
    t = P;  
    P = P->link;  
    free(t);  /* 删除临时生成的头结点 */ 
    return P; 
} 
//2.
Polynomial Add( Polynomial P1, Polynomial P2 ) 
{
    Polynomial  P, t1, t2, Rear, t;
    int c, e;
    t1 = P1; 
    t2 = P2;  
    P = Rear = (Polynomial)malloc(sizeof(struct PolyNode)); 
    Rear->link = NULL;  
    
    while (t1 && t2) 
    {   
        if (t1->expon == t2->expon) {
            e = t1->expon;
            c = t1->coef + t2->coef;
            if(c) Attach(c, e, &Rear); 
            t1 = t1->link;
            t2 = t2->link;
        }   
        else if (t1->expon > t2->expon) {
            e = t1->expon;
            c = t1->coef;
            if(c) Attach(c, e, &Rear); 
            t1 = t1->link;
        }   
        else {
            e = t2->expon;
            c = t2->coef;
            if(c) Attach(c, e, &Rear); 
            t2 = t2->link;
        }
    } 
    
    while (t1) {
        e = t1->expon;
        c = t1->coef;
        if(c) Attach(c, e, &Rear); 
        t1 = t1->link; 
    }  
    while (t2) {
        e = t2->expon;
        c = t2->coef;
        if(c) Attach(c, e, &Rear); 
        t2 = t2->link;
    }
    
    t = P;  
    P = P->link;  
    free(t);  /* 删除临时生成的头结点 */ 
    return P; 
}
//3.0
Polynomial Mult( Polynomial P1, Polynomial P2 ) 
{
    Polynomial P, Mul, t1, t2, t;  
    int c, e; 

    if (!P1 || !P2) return NULL; 
 
    t1 = P1; 
    t2 = P2;  
    P = Mul = NULL; 
    
    for(; t1; t1 = t1->link)
    {    
        for (t2 = P2; t2;  t2 = t2->link) 
        {
            e = t1->expon + t2->expon;    
            c = t1->coef * t2->coef;             
            if(c)
            {
                t = (Polynomial)malloc(sizeof(struct PolyNode));    
                t->coef = c; 
                t->expon = e;    
                t->link = NULL;
                
                if(Mul == NULL) P = Mul = t;
                else{
                    P = Add(t, Mul);
                    free(t);
                    DestroyPoly(&Mul);
                    Mul = P;
                }                
            }
        }
    }

    return P;     
}

#ifdef N
//3.1
Polynomial Mult( Polynomial P1, Polynomial P2 ) 
{
    Polynomial P, Rear, t1, t2, t;  
    int c, e; 

    if (!P1 || !P2) return NULL; 
 
    t1 = P1; 
    t2 = P2;  
    P = Rear = (Polynomial)malloc(sizeof(struct PolyNode)); 
    Rear->link = NULL; // P->link = NULL;
    
    while (t2) /* 先用P1的第1项乘以P2，得到P */ 
    {                            
        Attach(t1->coef*t2->coef, t1->expon+t2->expon, &Rear);   
        t2 = t2->link;  
    }  
    
    t1 = t1->link;/* 从第2项开始逐项相乘 */ 
    for(; t1; t1 = t1->link)
    {    
        Rear = P;         
        for (t2 = P2; t2;  t2 = t2->link) 
        {
            e = t1->expon + t2->expon;    
            c = t1->coef * t2->coef; 
            while (Rear->link && Rear->link->expon > e)//指数大    
                Rear = Rear->link;         
            if (Rear->link && Rear->link->expon == e)//指数相等 
            {    
                if (Rear->link->coef + c) /* 系数和大于0 */  
                    Rear->link->coef += c;    
                else {              /* 和等于0 */    
                    t = Rear->link;     
                    Rear->link = t->link;     
                    free(t);    
                }        
            }        
            else {                                 //指数小
                t = (Polynomial)malloc(sizeof(struct PolyNode));    
                t->coef = c; 
                t->expon = e;    
                t->link = Rear->link;    
                Rear->link = t; 
                Rear = Rear->link;        
            }
        }
    }
    t = P;  
    P = P->link;  
    free(t);  /* 删除临时生成的头结点 */ 
    return P;     
}
#endif
//4.
void PrintPoly( Polynomial P ) 
{   /* 输出多项式 */  
    int flag = 0;  /* 辅助调整输出格式用 */ 

    if (!P) {printf("0 0
"); return;} 

    while ( P ) 
    {   
        if (!flag) flag = 1;   
        else    printf(" ");   
        printf("%d %d", P->coef, P->expon);   
        P = P->link;  
    }  
    printf("
"); 
}     
 
int main() 
{    
    Polynomial P1, P2, PP, PS;
    
    P1 = ReadPoly();        
    P2 = ReadPoly();        
    PP = Mult( P1, P2 );        
    PrintPoly( PP );        
    PS = Add( P1, P2 );        
    PrintPoly( PS ); 
    
    return 0; 
}

02-线性结构3 Reversing Linked List

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (≤) which is the total number of nodes, and a positive K (≤) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:

00100 6 4

00000 4 99999

00100 1 12309

68237 6 -1

33218 3 00000

99999 5 68237

12309 2 33218

Sample Output:

00000 4 33218

33218 3 12309

12309 2 00100

00100 1 99999

99999 5 68237

68237 6 -1

/* 
1.结点的地址用数组的下标表示，通过数组下标可以索引到结点的Data值，结点的Next值;
2.从首结点的地址FirstAdd开始，通过索引Next把结点的地址串起来;
3.用一个顺序表List连续存储结点的地址，结点的关系是连续的下标表示，因为表元素值就是结点地址;
4.List逆序就是地址逆序，通过逆序后的地址(结点下标)可以索引到结点，List的下一个元素值，
就是结点的下一个结点地址;
 */
#include<stdio.h>
#define MaxSize 100005
int main()
{
    int Data[MaxSize];
    int Next[MaxSize];
    int list[MaxSize];
    int FirstAdd,N,K;
    scanf("%d %d %d",&FirstAdd,&N,&K);
    for(int i=0;i<N;i++){
        int tmpAdd,tmpData,tmpNext;
        scanf("%d %d %d",&tmpAdd,&tmpData,&tmpNext);
        Data[tmpAdd] = tmpData;
        Next[tmpAdd] = tmpNext;
    }
    int sum=0;   // 累计有效结点数 
    while(FirstAdd!=-1){   // 当尾结点为 -1 时结束 
        list[sum++] = FirstAdd;   // 记录所有Address
        FirstAdd = Next[FirstAdd];  // 找下一个结点 
    }
    for(int i=0;i<sum-sum%K;i+=K){  // 每 K 个结点一个区间 
        for(int j=0;j<K/2;j++){  // 反转链表
            int t = list[i+j];
            list[i+j] = list[i+K-j-1];
            list[i+K-j-1] = t; 
        }
    }
    for(int i=0;i<sum-1;i++)
        printf("%05d %d %05d
",list[i],Data[list[i]],list[i+1]);
    printf("%05d %d -1
",list[sum-1],Data[list[sum-1]]);
    return 0;
}

02-线性结构4 Pop Sequence

Given a stack which can keep M numbers at most. Push N numbers in the order of 1, 2, 3, ..., N and pop randomly. You are supposed to tell if a given sequence of numbers is a possible pop sequence of the stack. For example, if M is 5 and N is 7, we can obtain 1, 2, 3, 4, 5, 6, 7 from the stack, but not 3, 2, 1, 7, 5, 6, 4.

Input Specification:

Each input file contains one test case. For each case, the first line contains 3 numbers (all no more than 1000): M (the maximum capacity of the stack), N (the length of push sequence), and K (the number of pop sequences to be checked). Then K lines follow, each contains a pop sequence of N numbers. All the numbers in a line are separated by a space.

Output Specification:

For each pop sequence, print in one line "YES" if it is indeed a possible pop sequence of the stack, or "NO" if not.

Sample Input:

5 7 5

1 2 3 4 5 6 7

3 2 1 7 5 6 4

7 6 5 4 3 2 1

5 6 4 3 7 2 1

1 7 6 5 4 3 2

Sample Output:

YES

NO

NO

YES

NO

#include <stdio.h>
#define N 1000
int main()
{
    int m,n,k;//m栈的最大容量, n压栈元素个数, k行测试数列
    scanf("%d%d%d", &m, &n, &k);
    for(int i=0; i<k; i++)//k行测试数列
    {
        int stack[N]; //栈
        int top = -1; 
        int arr[N];   //数列数组
        for(int j=0; j<n; j++)//输入一个数列
            scanf("%d", &arr[j]);
        int count = 0; //相同个数(作为arr下标)
        for(int j=1; j<=n; j++)//从数字1开始压栈
        {
            stack[++top] = j;//压栈
            if(top + 1 > m)//第一个栈元素下标为0
                break;        
            while(top != -1 && stack[top]==arr[count])
            {    
                top--;
                count++;                        
            }
        }
        if(count == n)
            printf("YES
");
        else
            printf("NO
");
    }
    return 0;
}

03-树1 树的同构

给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。

 

图1

 

 

图2

现给定两棵树，请你判断它们是否是同构的。

输入格式:

输入给出2棵二叉树树的信息。对于每棵树，首先在一行中给出一个非负整数N (≤10)，即该树的结点数（此时假设结点从0到N−1编号）；随后N行，第i行对应编号第i个结点，给出该结点中存储的1个英文大写字母、其左孩子结点的编号、右孩子结点的编号。如果孩子结点为空，则在相应位置上给出“-”。给出的数据间用一个空格分隔。注意：题目保证每个结点中存储的字母是不同的。

输出格式:

如果两棵树是同构的，输出“Yes”，否则输出“No”。

输入样例1（对应图1）：

8

A 1 2

B 3 4

C 5 -

D - -

E 6 -

G 7 -

F - -

H - -

8

G - 4

B 7 6

F - -

A 5 1

H - -

C 0 -

D - -

E 2 -  

输出样例1:

Yes

输入样例2（对应图2）：

8

B 5 7

F - -

A 0 3

C 6 -

H - -

D - -

G 4 -

E 1 -

8

D 6 -

B 5 -

E - -

H - -

C 0 2

G - 3

F - -

A 1 4  

输出样例2:

No

#include <stdio.h>
#include <malloc.h>
#define null -1
/* 定义树结点 */
struct TreeNode{
    char data;  // 存值 
    int left;   // 左子树的下标 
    int right;  // 右子树的下标 
}T1[10],T2[10];

/* 构造树并返回根结点  */
int create(struct TreeNode T[])
{
    int n;
    int root = 0;
    char left, right;
    /* 输入结点数 */
    scanf("%d", &n);
    /* 空树 */
    if(!n)
        return null;
    for(int i=0;i<n;i++)
    {      
        root +=i;  /* 累加i*/  
        /* 输入数据 */
        scanf(" %c %c %c", &T[i].data, &left, &right);
        /* 1.left */
        if(left=='-')
            T[i].left = null;
        else{
            T[i].left = left-'0';
            root -= T[i].left; //减
        }
        /* 2.right */
        if(right=='-')
            T[i].right = null;
        else{
            T[i].right = right-'0';
            root -= T[i].right;//减        
        }        
    }
    return root;
}
/* 判断是否同构 */
int judge(int R1,int R2)
{
    /* 1.两棵树都为空  */
    if(R1 == null && R2 == null)
        return 1;
    /* 2.一个为空，一个不为空 */
    if(R1 == null && R2 != null || R1 != null && R2 == null)
        return 0;
    /* 3.两颗树的值不同 */
    if(T1[R1].data != T2[R2].data) 
        return 0;
    /* 4.左儿子为空*/
    if(T1[R1].left == null && T2[R2].left == null)
        return judge(T1[R1].right,T2[R2].right);
    /* 5.左儿子不为空且值相等*/
    if((T1[R1].left != null && T2[R2].left != null )
                            &&(T1[T1[R1].left].data == T2[T2[R2].left].data))        
        return judge(T1[R1].left,T2[R2].left) 
                            &&judge(T1[R1].right,T2[R2].right);                                        
    /* 6.左儿子不为空且值不等 或者 某一个树的左儿子为空*/
    else   
        return judge(T1[R1].right,T2[R2].left)
            && judge(T1[R1].left,T2[R2].right);            
} 
int main()
{
    int R1,R2;
    R1 = create(T1);
    R2 = create(T2);
    if(judge(R1,R2))
        printf("Yes");
    else
        printf("No");
    return 0;
} 

03-树2 List Leaves

Given a tree, you are supposed to list all the leaves in the order of top down, and left to right.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤10) which is the total number of nodes in the tree -- and hence the nodes are numbered from 0 to N−1. Then N lines follow, each corresponds to a node, and gives the indices of the left and right children of the node. If the child does not exist, a "-" will be put at the position. Any pair of children are separated by a space.

Output Specification:

For each test case, print in one line all the leaves' indices in the order of top down, and left to right. There must be exactly one space between any adjacent numbers, and no extra space at the end of the line.

Sample Input:

8

1 -

- -

0 -

2 7

- -

- -

5 -

4 6

Sample Output:

4 1 5

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

/* 定义树结构(顺序存储) */
#define null -1 //-1 表示空
struct TreeNode{
    int data;   // 数据 0~N-1
    int left;   // 左儿子下标
    int right;  // 右儿子下标
}T[10]; //最大10个结点

/* 顺序循环队列(队头指针在第一个元素前)*/
#define MAXSIZE  10 //最大队列长度 N 
typedef int Position; //队列的头尾指针类型
typedef struct TreeNode ElementType; //队列元素类型 
typedef struct QNode *Queue; 
struct QNode {
    ElementType *Data;     /* 存储元素的数组 */
    Position Front, Rear;  /* 队列的头、尾指针 */
    int MaxSize;           /* 队列最大容量 */
};

 /* 建队列 */
Queue CreateQueue( int MaxSize )//返回队列指针
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (ElementType *)malloc(MaxSize * sizeof(ElementType));
    Q->Front = Q->Rear = 0;
    Q->MaxSize = MaxSize;
    return Q;
}

/* 队满 */
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MaxSize == Q->Front);
}

/* 队空 */
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}

/* 入队 */
bool AddQ( Queue Q, ElementType X )
{
    if ( IsFull(Q) ) {
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MaxSize;
        Q->Data[Q->Rear] = X;
        return true;
    }
}

/* 出队 */
ElementType* DeleteQ( Queue Q )
{    
    if ( IsEmpty(Q) )
        return NULL;
    Q->Front =(Q->Front+1)%Q->MaxSize;
    return  &Q->Data[Q->Front];   
}

//  树结点输入
int create()
{
    int n;
    int root = 0;
    char left, right;
    
    scanf("%d", &n);
    if(!n) //结点数为0, 返回空(-1)
        return null;
    
    for(int i=0; i<n; i++)
    {
        root += i;//累加
        T[i].data = i; //数据0~N-1
        
        scanf(" %c %c", &left, &right);
        
        if(left=='-')//左儿子下标
            T[i].left = null;
        else{
            T[i].left = left-'0';
            root -= T[i].left;//减
        }
        
        if(right=='-')//右儿子下标
            T[i].right = null;
        else{
            T[i].right = right-'0';
            root -= T[i].right;//减
        }    
    }
    return root;
}

// 层序遍历(从上到下从左到右) 
void LevelorderTraversal(int root)
{        
    if(root == null){
        printf("-");// 树为空,输出"-"
        return;    
    }
    
    Queue q = CreateQueue(MAXSIZE);//建队列(指针)
    bool flag = false; //控制空格输出
    AddQ(q, T[root]); //树根入队
    
    while(!IsEmpty(q))
    {    
        ElementType* t = DeleteQ(q);// 出队, 返回队首元素
        
        if(t->left == null && t->right == null)
        {  //如果为叶子结点就输出     
            if(flag)
                printf(" ");
            else
                flag = true;
            printf("%d", t->data);
        }
        
        if(t->left != null)  // 有左儿子入队
            AddQ(q, T[t->left]);
        if(t->right != null)  // 有右儿子入队
            AddQ(q, T[t->right]);
    }
}
 
int main()
{
    int root = create();
    LevelorderTraversal(root);
    return 0;
} 

03-树3 Tree Traversals Again

An inorder binary tree traversal can be implemented in a non-recursive way with a stack. For example, suppose that when a 6-node binary tree (with the keys numbered from 1 to 6) is traversed, the stack operations are: push(1); push(2); push(3); pop(); pop(); push(4); pop(); pop(); push(5); push(6); pop(); pop(). Then a unique binary tree (shown in Figure 1) can be generated from this sequence of operations. Your task is to give the postorder traversal sequence of this tree.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤30) which is the total number of nodes in a tree (and hence the nodes are numbered from 1 to N). Then 2N lines follow, each describes a stack operation in the format: "Push X" where X is the index of the node being pushed onto the stack; or "Pop" meaning to pop one node from the stack.

Output Specification:

For each test case, print the postorder traversal sequence of the corresponding tree in one line. A solution is guaranteed to exist. All the numbers must be separated by exactly one space, and there must be no extra space at the end of the line.

　　Figure 1

Sample Input:

6

Push 1

Push 2

Push 3

Pop

Pop

Push 4

Pop

Pop

Push 5

Push 6

Pop

Pop

Sample Output:

3 4 2 6 5 1

#include <stdio.h>
#include <stdlib.h> //atoi
#include <string.h> //strcmp

#define N 31
typedef int ElementType;
typedef struct TreeNode *Tree;//树类型
struct TreeNode{
    ElementType data;  // 数字 1 ~ N
    Tree left;         // 左子树 
    Tree right;        // 右子树 
};

typedef Tree Stack;//树栈类型

//先序遍历建树 
Tree PreorderTraversal()
{
    Tree T = (Tree)malloc(sizeof(struct TreeNode));
    T->left = NULL;
    T->right = NULL; //树根
    Tree t = T;         
    
    Stack s[N];    //树栈
    int top = -1;
    
    int n;    
    scanf("%d
",&n);
    
    char str[N];   //字符串        
    gets(str);
    
    t->data = atoi(&str[5]); // 根节点data     
    s[++top] = t;            //根结点入栈 

    for(int i=1; i<2*n; i++) //2N lines
    {
        gets(str);              //逐行读取
        if(!strcmp(str,"Pop")){ //Pop
            t = s[top];         //出栈指针
            top--; 
        }else{                  // Push    
            Tree tmp  = (Tree)malloc(sizeof(struct TreeNode));
            tmp->left = NULL;
            tmp->right = NULL; 
            tmp->data = atoi(&str[5]); //树结点data    
            s[++top] = tmp;     //新结点入栈
            
            if(!t->left){       // 左插
                t->left = tmp;
                t = t->left; 
            }else if(!t->right){ //右插
                t->right = tmp;
                t = t->right;
            }            
        }
    }
    return T;
}

// 后序递归遍历
void PostorderTraversal(Tree T, int *flag)
{
    if(T){
        PostorderTraversal(T->left,flag);
        PostorderTraversal(T->right,flag);
        if(!(*flag))
            *flag = 1;
        else
            printf(" ");
        printf("%d", T->data);
    }
} 

int main()
{
    Tree T = PreorderTraversal(); //先序建树
    int flag = 0;
    PostorderTraversal(T,&flag); //后序输出
    return 0;
}

04-树7 二叉搜索树的操作集

本题要求实现给定二叉搜索树的5种常用操作。

函数接口定义：

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

其中BinTree结构定义如下：

typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针；

函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针；

函数Find在二叉搜索树BST中找到X，返回该结点的指针；如果找不到则返回空指针；

函数FindMin返回二叉搜索树BST中最小元结点的指针；

函数FindMax返回二叉搜索树BST中最大元结点的指针。

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

typedef int ElementType;
typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

void PreorderTraversal( BinTree BT ); /* 先序遍历，由裁判实现，细节不表 */
void InorderTraversal( BinTree BT );  /* 中序遍历，由裁判实现，细节不表 */

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

int main()
{
    BinTree BST, MinP, MaxP, Tmp;
    ElementType X;
    int N, i;

    BST = NULL;
    scanf("%d", &N);
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Insert(BST, X);
    }
    printf("Preorder:"); PreorderTraversal(BST); printf("
");
    MinP = FindMin(BST);
    MaxP = FindMax(BST);
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        Tmp = Find(BST, X);
        if (Tmp == NULL) printf("%d is not found
", X);
        else {
            printf("%d is found
", Tmp->Data);
            if (Tmp==MinP) printf("%d is the smallest key
", Tmp->Data);
            if (Tmp==MaxP) printf("%d is the largest key
", Tmp->Data);
        }
    }
    scanf("%d", &N);
    for( i=0; i<N; i++ ) {
        scanf("%d", &X);
        BST = Delete(BST, X);
    }
    printf("Inorder:"); InorderTraversal(BST); printf("
");

    return 0;
}
/* 你的代码将被嵌在这里 */

输入样例：

10
5 8 6 2 4 1 0 10 9 7
5
6 3 10 0 5
5
5 7 0 10 3

输出样例：

Preorder: 5 2 1 0 4 8 6 7 10 9
6 is found
3 is not found
10 is found
10 is the largest key
0 is found
0 is the smallest key
5 is found
Not Found
Inorder: 1 2 4 6 8 9

// 插入 
BinTree Insert( BinTree BST, ElementType X ){
    if(!BST){  // 如果为空，创建新结点 
        BST = (BinTree)malloc(sizeof(struct TNode));
        BST->Data = X;
        BST->Left = NULL;
        BST->Right = NULL;
    }else{
        if(X < BST->Data)
            BST->Left = Insert(BST->Left,X);
        else if(BST->Data < X)
            BST->Right = Insert(BST->Right,X);
    }
    return BST; 
}

// 删除
BinTree Delete( BinTree BST, ElementType X ){
    BinTree tmp;
    if(!BST){
        printf("Not Found
");
        return BST;
    }else{
        if(X < BST->Data)
            BST->Left = Delete(BST->Left,X);
        else if(BST->Data < X)
            BST->Right = Delete(BST->Right,X);
        else{  // 找到要删除结点 
            if(BST->Left && BST->Right){  // 如果该结点有左右儿子 
                tmp = FindMin(BST->Right);
                BST->Data = tmp->Data;
                BST->Right = Delete(BST->Right,tmp->Data);
            }else{
                tmp = BST;
                if(BST->Left && !BST->Right)
                    BST = BST->Left;
                else if(!BST->Left && BST->Right)
                    BST = BST->Right;
                else
                    BST = NULL;
                free(tmp);
            }
        }
    }
    return BST;
} 

// 寻找值最小结点 
Position FindMin( BinTree BST ){
    if(BST)
        while(BST->Left)
            BST = BST->Left;
    return BST;
}

// 寻找值最大结点
Position FindMax( BinTree BST ){
    if(BST)
        while(BST->Right)
            BST = BST->Right;
    return BST;
} 

// 查找
Position Find( BinTree BST, ElementType X ){
    if(!BST){
        return NULL;
    }else if(X < BST->Data)
        return Find(BST->Left,X);
    else if(BST->Data < X)
        return Find(BST->Right,X);
    else
        return BST;
} 

04-树4 是否同一棵二叉搜索树 

给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的各种插入序列，你需要判断它们是否能生成一样的二叉搜索树。 

输入格式:

输入包含若干组测试数据。每组数据的第1行给出两个正整数N (≤10)和L，分别是每个序列插入元素的个数和需要检查的序列个数。第2行给出N个以空格分隔的正整数，作为初始插入序列。最后L行，每行给出N个插入的元素，属于L个需要检查的序列。

简单起见，我们保证每个插入序列都是1到N的一个排列。当读到N为0时，标志输入结束，这组数据不要处理。

输出格式:

对每一组需要检查的序列，如果其生成的二叉搜索树跟对应的初始序列生成的一样，输出“Yes”，否则输出“No”。

输入样例:

4 2
3 1 4 2
3 4 1 2
3 2 4 1
2 1
2 1
1 2
0

输出样例:

Yes
No
No

#include <stdio.h>
#include <malloc.h>
/* 树结点定义 */
typedef struct TreeNode *Tree;
struct TreeNode {
    int v;
    Tree Left, Right;
    int flag; /* 判别结点是否访问过的标记 */
};

/* 函数声明 
   1.创建一个树结点
   2.插入一个树结点
   3.创建一棵树
   4.检查树结点是否访问过
   5.判断是否同一棵树
   6.清除树中各结点的flag标记
   7.释放树的空间
*/
Tree NewNode( int V );
Tree Insert( Tree T, int V );
Tree MakeTree( int N );
int check ( Tree T, int V );
int Judge( Tree T, int N );
void ResetT ( Tree T );
void FreeTree ( Tree T );

/* 主程序 */
int main()
{
    int N, L, i;
    Tree T; /* 创建一个树的空结点 */
    scanf("%d", &N);
    while (N) 
    {
        scanf("%d", &L);
        T = MakeTree(N); /* 创建一棵N个结点的树 */
        for (i=0; i<L; i++) 
        {   /* 判断是否同一棵树 */
            if (Judge(T, N)) printf("Yes
");
            else printf("No
");
            ResetT(T); /*清除T中的标记flag*/
        }
        FreeTree(T); /* 释放上面的树空间 */
        scanf("%d", &N);
    }
    return 0; 
}
/* 创建一个树结点 */
Tree NewNode( int V )
{ 
    Tree T = (Tree)malloc(sizeof(struct TreeNode));
    T->v = V;
    T->Left = T->Right = NULL;
    T->flag = 0;
    return T;
}
/* 插入一个树结点 */
Tree Insert( Tree T, int V )
{
    if ( !T ) T = NewNode(V);
    else 
    {
        if ( V > T->v )
            T->Right = Insert( T->Right, V );
        else
            T->Left = Insert( T->Left, V );
    }
    return T;
}
/* 创建一棵N个结点的树 */
Tree MakeTree( int N )
{ 
    Tree T;
    int i, V;
    scanf("%d", &V);
    T = NewNode(V); /*  */
    for (i=1; i<N; i++) 
    {
        scanf("%d", &V);
        T = Insert(T, V); /*  */
    }
    return T;
}
/* 判断树的结点是否访问过 */
int check ( Tree T, int V )
{
    if ( T->flag ) 
    {
        if ( V<T->v ) return check(T->Left, V);
        else if ( V>T->v ) return check(T->Right, V);
        else return 0;
    }
    else 
    {
        if ( V==T->v ) 
        {
            T->flag = 1;
            return 1;
        }
        else return 0;
    }
}
/* 判断是否同一棵树 */
int Judge( Tree T, int N )
{
    int i, V, flag = 0;
    /* flag,  0代表目前还一致, 1代表已经不一致*/
    scanf("%d", &V);
    if ( V!=T->v ) flag = 1;
    else T->flag = 1;
    for (i=1; i<N; i++) 
    {
        scanf("%d", &V);/* 读取结点的V */
        if ( (!flag) && (!check(T, V)) ) flag = 1;
    }
    return !flag; /* 1代表已经不一致 */
}
/* 清除T中各结点的flag标记 */
void ResetT ( Tree T ) 
{
    if (T->Left) ResetT(T->Left);
    if (T->Right) ResetT(T->Right);
    T->flag = 0;
}
/* 释放T的空间 */
void FreeTree ( Tree T ) 
{
    if (T->Left) FreeTree(T->Left);
    if (T->Right) FreeTree(T->Right);
    free(T);
}

04-树5 Root of AVL Tree

An AVL tree is a self-balancing binary search tree. In an AVL tree, the heights of the two child subtrees of any node differ by at most one; if at any time they differ by more than one, rebalancing is done to restore this property. Figures 1-4 illustrate the rotation rules.

Now given a sequence of insertions, you are supposed to tell the root of the resulting AVL tree.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤20) which is the total number of keys to be inserted. Then N distinct integer keys are given in the next line. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print the root of the resulting AVL tree in one line.

Sample Input 1:

5
88 70 61 96 120

Sample Output 1:

70

Sample Input 2:

7
88 70 61 96 120 90 65

Sample Output 2:

88

#include <stdio.h>
#include <malloc.h>

typedef int ElementType;
typedef struct AVLNode *Position;
typedef Position AVLTree; /* AVL树类型 */
struct AVLNode{
    ElementType Data; /* 结点数据 */
    AVLTree Left;     /* 指向左子树 */
    AVLTree Right;    /* 指向右子树 */
    int Height;       /* 树高 */
};

/* AVL树左右单旋左右双旋右左双旋插入 */
int GetHeight( AVLTree A ); /* 树高 */
int Max ( int a, int b );   /* 结点数据大小 */
AVLTree SingleLeftRotation ( AVLTree A );
AVLTree SingleRightRotation ( AVLTree A ); 
AVLTree DoubleLeftRightRotation ( AVLTree A );
AVLTree DoubleRightLeftRotation ( AVLTree A );
AVLTree Insert( AVLTree T, ElementType X );
 
/* 主程序 */
int main()
{
    AVLTree AVLT = NULL;
    int N, i;
    ElementType X;
    scanf("%d", &N);
    for ( i=0; i<N; i++ ) {
        scanf("%d", &X);
        AVLT = Insert(AVLT, X);
    }
    printf("%d
", AVLT->Data);
    return 0; 
}

/* 树高 */
int GetHeight(AVLTree A)
{
    if(!A) return -1;
    return A->Height;
}

/* 树数据大小 */
int Max ( int a, int b )
{
    return a > b ? a : b;
}

/* 左单旋 */
AVLTree SingleLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B */
  /* 将A与B做左单旋，更新A与B的高度，返回新的根结点B */     
 
    AVLTree B = A->Left;
    A->Left = B->Right;
    B->Right = A;
    A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
    B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
  
    return B;
}

/* 右单旋 */
AVLTree SingleRightRotation ( AVLTree A )
{ /* 注意：A必须有一个右子结点B */
  /* 将A与B做右单旋，更新A与B的高度，返回新的根结点B */     
 
    AVLTree B = A->Right;
    A->Right = B->Left;
    B->Left = A;
    A->Height = Max( GetHeight(A->Left), GetHeight(A->Right) ) + 1;
    B->Height = Max( GetHeight(B->Left), A->Height ) + 1;
  
    return B;
}

/* 左右双旋 */
AVLTree DoubleLeftRightRotation ( AVLTree A )
{ /* 注意：A必须有一个左子结点B，且B必须有一个右子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
     
    /* 将B与C做右单旋，C被返回 */
    A->Left = SingleRightRotation(A->Left);
    /* 将A与C做左单旋，C被返回 */
    return SingleLeftRotation(A);
}

/* 右左双旋 */
AVLTree DoubleRightLeftRotation ( AVLTree A )
{ /* 注意：A必须有一个右子结点B，且B必须有一个左子结点C */
  /* 将A、B与C做两次单旋，返回新的根结点C */
     
    /* 将B与C做右单旋，C被返回 */
    A->Right = SingleLeftRotation(A->Right);
    /* 将A与C做右单旋，C被返回 */
    return SingleRightRotation(A);
}

/* 插入 */
AVLTree Insert( AVLTree T, ElementType X )
{ /* 将X插入AVL树T中，并且返回调整后的AVL树 */
    if ( !T ) { /* 若插入空树，则新建包含一个结点的树 */
        T = (AVLTree)malloc(sizeof(struct AVLNode));
        T->Data = X;
        T->Height = 0;
        T->Left = T->Right = NULL;
    } /* if (插入空树) 结束 */
 
    else if ( X < T->Data ) {
        /* 插入T的左子树 */
        T->Left = Insert( T->Left, X);
        /* 如果需要左旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == 2 )
            if ( X < T->Left->Data ) 
               T = SingleLeftRotation(T);      /* 左单旋 */
            else 
               T = DoubleLeftRightRotation(T); /* 左-右双旋 */
    } /* else if (插入左子树) 结束 */
     
    else if ( X > T->Data ) {
        /* 插入T的右子树 */
        T->Right = Insert( T->Right, X );
        /* 如果需要右旋 */
        if ( GetHeight(T->Left)-GetHeight(T->Right) == -2 )
            if ( X > T->Right->Data ) 
               T = SingleRightRotation(T);     /* 右单旋 */
            else 
               T = DoubleRightLeftRotation(T); /* 右-左双旋 */
    } /* else if (插入右子树) 结束 */
 
    /* else X == T->Data，无须插入 */
 
    /* 别忘了更新树高 */
    T->Height = Max( GetHeight(T->Left), GetHeight(T->Right) ) + 1;
     
    return T;
}

04-树6 Complete Binary Search Tree 

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

The left subtree of a node contains only nodes with keys less than the node's key.

The right subtree of a node contains only nodes with keys greater than or equal to the node's key.

Both the left and right subtrees must also be binary search trees.

A Complete Binary Tree (CBT) is a tree that is completely filled, with the possible exception of the bottom level, which is filled from left to right.

Now given a sequence of distinct non-negative integer keys, a unique BST can be constructed if it is required that the tree must also be a CBT. You are supposed to output the level order traversal sequence of this BST.

Input Specification:

Each input file contains one test case. For each case, the first line contains a positive integer N (≤1000). Then N distinct non-negative integer keys are given in the next line. All the numbers in a line are separated by a space and are no greater than 2000.

Output Specification:

For each test case, print in one line the level order traversal sequence of the corresponding complete binary search tree. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input:

10

1 2 3 4 5 6 7 8 9 0

Sample Output:

6 3 8 1 5 7 9 0 2 4

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

#define MaxSize 2001
int value[MaxSize]; /* BST树 */
int BST[MaxSize];   /* 完全二叉树 */

/* 计算 n 个结点的树其左树结点个数 */ 
int getLeftTreeSize(int n)
{    
    int h = 0;   /* 0.保存该结点下满二叉树的层数 */ 
    int tmp = n+1;    /* n+1, 结点为1的情况下,1+1除以2结果为1 */
    while( tmp != 1 )
    {
        tmp /= 2; /* 每层比上一层多2倍, 除以2就是一层 */
        h++;
    }
    /* 1.最下面一排叶结点个数 */ 
    int x = n - (pow(2,h)-1); 
    /* 2.左子树的叶结点个数最多是 2^(h-1) 
        如果最下一排叶结点含有右树叶结点,即大于2^(h-1)
        取左子树最大叶结点数2^(h-1) */
    x = x<pow(2,h-1) ? x: pow(2,h-1); 
    /* 3.左子树的个数 */ 
    int L = pow(2,h-1)-1 + x;  
    /* 
        左满树 + 左叶子结点 == 左子树的结点数, 
        左满树 比 根满树 低一层 pow(2,h-1)-1 
        根满树pow(2,h)-1
        根满树 + 最下面一排叶子结点数 == n
    */
    return L;
}

/* 填充函数 */
void fill(int left,int right,int root)
{
    int n = right - left + 1;  // 确定范围内数值个数 
     if(!n)
         return;
     int L = getLeftTreeSize(n);   // 找到"偏移量"     
     BST[root] = value[left + L];  // 根结点的值 左边界值 + 偏移量     
     int leftRoot = 2 * root + 1;   // 左儿子结点位置，由于从 0 开始 
     int rightRoot = leftRoot + 1;  // 右儿子结点位置     
     fill(left, left+L-1, leftRoot);    // 左子树递归 
     fill(left+L+1, right, rightRoot);  // 右子树递归 
}

void QuickSort(int *a, int n, int left, int right)
{
    int i, j, t; 
        /*左指针left指向数组头 右指针right指向数组尾*/
    if(left<right)
    {
        i = left, j = right+1;/*左右指针*/
        while(i<j)
        {
            while(i+1<n && a[++i]<a[left]);/*左指针右移 指向大于基数的数据停止*/
            while(j-1>-1 && a[--j]>a[left]);/*右指针左移 指向小于基数的数据停止*/
            if(i<j)/*满足左指针小于右指针的条件 两指针指向数据交换*/
                t = a[i], a[i] = a[j], a[j] = t;         
        }
        t = a[left], a[left] = a[j], a[j] = t;/*右指针指向数据与基数交换*/
        QuickSort(a, n, left, j-1);/*左边数据递归*/
        QuickSort(a, n, j+1, right);/*右边数据递归*/
    }
}

int main()
{
    int n;
    scanf("%d", &n);
    for(int i=0;i<n;i++) 
        scanf("%d", &value[i]); 
    /* BST树左小右大的属性 */
    QuickSort( value, n, 0, n-1 ); /* 从小到大排序  */
    fill( 0, n-1, 0 ); /* 完全二叉树填充,下标从0开始 */
    for(int i=0;i<n;i++)
    {
        if(i)
            printf(" ");
        printf("%d", BST[i]);
    }
    return 0;
}

05-树7 堆中的路径

将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i，打印从H[i]到根结点的路径。

输入格式:

每组测试第1行包含2个正整数N和M(≤1000)，分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。

输出格式:

对输入中给出的每个下标i，在一行中输出从H[i]到根结点的路径上的数据。数字间以1个空格分隔，行末不得有多余空格。

输入样例:

5 3

46 23 26 24 10

5 4 3

输出样例:

24 23 10

46 23 10

26 10

#include <stdio.h>

/* 1.定义堆H */
#define MAXN 1001
#define MINH -10001
int H[MAXN], size;

/* 2.堆的初始化 */
void Create ()
{
    size = 0;
    H[0] = MINH;
}

/* 3.堆插入 */
void Insert ( int X )
{
    int i; 
    for (i=++size; H[i/2] > X; i/=2)
        H[i] = H[i/2];
    H[i] = X;
}

int main()
{    
    int n, m, x, i, j;
    scanf("%d%d", &n, &m);
    Create(); 
    for (i=0; i<n; i++) { 
        scanf("%d", &x);
        Insert(x); 
    }
        
    for (i=0; i<m; i++) 
    {
        scanf("%d", &j);
        printf("%d", H[j]);     
        while (j>1) {
            j /= 2;
            printf(" %d", H[j]);
        }
        printf("
");
    }
    return 0;
}

05-树8 File Transfer

We have a network of computers and a list of bi-directional connections. Each of these connections allows a file transfer from one computer to another. Is it possible to send a file from any computer on the network to any other?

Input Specification:

Each input file contains one test case. For each test case, the first line contains N (2≤N≤10

​4), the total number of computers in a network. Each computer in the network is then represented by a positive integer between 1 and N. Then in the following lines, the input is given in the format:

I c1 c2 

where I stands for inputting a connection between c1 and c2; or

C c1 c2   

where C stands for checking if it is possible to transfer files between c1 and c2; or

S

where S stands for stopping this case.

Output Specification:

For each C case, print in one line the word "yes" or "no" if it is possible or impossible to transfer files between c1 and c2, respectively. At the end of each case, print in one line "The network is connected." if there is a path between any pair of computers; or "There are k components." where k is the number of connected components in this network.

Sample Input 1:

5

C 3 2

I 3 2

C 1 5

I 4 5

I 2 4

C 3 5

S

Sample Output 1:

no

no

yes

There are 2 components.

Sample Input 2:

5

C 3 2

I 3 2

C 1 5

I 4 5

I 2 4

C 3 5

I 1 3

C 1 5

S

Sample Output 2:

no

no

yes

yes

The network is connected.

#include <stdio.h>
 
/* 集合的简化 */
#define MaxSize 10001 
typedef int ElementType; /*默认元素可以用非负整数表示*/
typedef int SetName; /*默认用根结点的下标作为集合名称*/
typedef ElementType SetType[MaxSize];/* 定义集合类型 */

/* Initialization */
void Initialization( SetType S , int n )
{
    int i;
    for ( i=0; i<n; i++ ) S[i] = -1;
}

/* find */
SetName Find( SetType S, ElementType X )
{ 
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else    
        return S[X] = Find( S, S[X] );
}

/* union */
void Union( SetType S, SetName Root1, SetName Root2 )
{     /* 按规模 比元素个数,少的贴多的 */
    if ( S[Root2]<S[Root1] ){ //负数,小即多
        S[Root2] += S[Root1];
        S[Root1] = Root2;
    }
    else {
        S[Root1] += S[Root2];
        S[Root2] = Root1;
    }
}

/* input */
void Input_connection( SetType S )
{ 
    ElementType u, v;
    SetName Root1, Root2;
    scanf("%d %d
", &u, &v);
    Root1 = Find(S, u-1);
    Root2 = Find(S, v-1);
    if ( Root1 != Root2 )
        Union( S, Root1, Root2 );
}

/* check connection */
void Check_connection( SetType S )
{ 
    ElementType u, v;
    SetName Root1, Root2;
    scanf("%d %d
", &u, &v);
    Root1 = Find(S, u-1);
    Root2 = Find(S, v-1);
    if ( Root1 == Root2 )
        printf("yes
");
    else printf("no
");
}

/* check network */
void Check_network( SetType S, int n )
{ 
    int i, counter = 0;
    for (i=0; i<n; i++) {
        if ( S[i] < 0 ) counter++;
    }
    if ( counter == 1 )
        printf("The network is connected.
");
    else
        printf("There are %d components.
", counter);
}

/* 测试 */
int main()
{   
    SetType S;
    int n;
    char in;
    scanf("%d
", &n);
    Initialization( S, n );
    do {
        scanf("%c", &in);
        switch (in) {
            case 'I': Input_connection( S ); break;
            case 'C': Check_connection( S ); break;
            case 'S': Check_network( S, n ); break;
        }
    } while ( in != 'S');
    return 0;
}

05-树9 Huffman Codes

In 1953, David A. Huffman published his paper "A Method for the Construction of Minimum-Redundancy Codes", and hence printed his name in the history of computer science. As a professor who gives the final exam problem on Huffman codes, I am encountering a big problem: the Huffman codes are NOT unique. For example, given a string "aaaxuaxz", we can observe that the frequencies of the characters 'a', 'x', 'u' and 'z' are 4, 2, 1 and 1, respectively. We may either encode the symbols as {'a'=0, 'x'=10, 'u'=110, 'z'=111}, or in another way as {'a'=1, 'x'=01, 'u'=001, 'z'=000}, both compress the string into 14 bits. Another set of code can be given as {'a'=0, 'x'=11, 'u'=100, 'z'=101}, but {'a'=0, 'x'=01, 'u'=011, 'z'=001} is NOT correct since "aaaxuaxz" and "aazuaxax" can both be decoded from the code 00001011001001. The students are submitting all kinds of codes, and I need a computer program to help me determine which ones are correct and which ones are not.

Input Specification:

Each input file contains one test case. For each case, the first line gives an integer N (2≤N≤63), then followed by a line that contains all the N distinct characters and their frequencies in the following format:

c[1] f[1] c[2] f[2] ... c[N] f[N]

where c[i] is a character chosen from {'0' - '9', 'a' - 'z', 'A' - 'Z', '_'}, and f[i] is the frequency of c[i] and is an integer no more than 1000. The next line gives a positive integer M (≤1000), then followed by M student submissions. Each student submission consists of N lines, each in the format:

c[i] code[i]

where c[i] is the i-th character and code[i] is an non-empty string of no more than 63 '0's and '1's.

Output Specification:

For each test case, print in each line either "Yes" if the student's submission is correct, or "No" if not.

Note: The optimal solution is not necessarily generated by Huffman algorithm. Any prefix code with code length being optimal is considered correct.

Sample Input:

7
A 1 B 1 C 1 D 3 E 3 F 6 G 6
4
A 00000
B 00001
C 0001
D 001
E 01
F 10
G 11
A 01010
B 01011
C 0100
D 011
E 10
F 11
G 00
A 000
B 001
C 010
D 011
E 100
F 101
G 110
A 00000
B 00001
C 0001
D 001
E 00
F 10
G 11

Sample Output:

Yes
Yes
No
No

/* 
    建一个最小堆, 堆插入树结点, 形成树结点森林;
    每次从堆中取2个最小树结点, 建中间树结点并插入堆;
    最后堆中森林形成一棵Huffman树并计算WPL; 
    判断前缀码结点数WPL, 确定编码是否正确;
*/

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

/* 二叉树结点 */
typedef struct TreeNode* Tree;
struct TreeNode {
    int Weight;
    Tree Left, Right;
};

/* 堆(优先队列) */
#define MAXSIZE 256 
typedef struct HeapNode* Heap;
struct HeapNode {   
    struct TreeNode Data[MAXSIZE];/* 完全二叉树顺序存储 */
    int Size;
};
 
Tree NewTreeNode();/* 建树结点 */
Heap CreatHeap(); /* 建空堆 */
void Insert(Heap H, struct TreeNode T);/* 堆插入 */
Tree Delete(Heap H);/* 堆删除 */
Tree Huffman(Heap H); /* 建Huffman树 */
int WPL(Tree T, int Depth);/* 整棵树的WPL */

int Judge(int codelen, int Weight[], int N) ; /* 判断是否正确的Huffman编码 */

int main() 
{
    int N, Weight[MAXSIZE] = {0};
    char ch;
   
    Heap H = CreatHeap(); /* 建空堆 */
    Tree T = NewTreeNode();  /* 建临时树结点 */
    
    scanf("%d", &N);  /* 树结点个数 */
    for(int i = 0; i < N; i++) 
    {   
        scanf(" %c", &ch);    
        scanf("%d", &Weight[ch]);    
        T->Weight = Weight[ch];
        H->Data[H->Size].Left = H->Data[H->Size].Right = NULL;       
        Insert(H, *T); /* 复制创建的树结点(传参), 插入堆, 形成树森林 */
    }
    
    free(T); /* 释放临时结点 */
    
    T = Huffman(H);   /* 建Huffman树  */
    
    int codelen = WPL(T, 0); /* 求Huffman树的WPL */    
    int M;  /* M棵树 */
    scanf("%d", &M);
    
    while(M--) 
    {    /* 一次判断一棵树 */
        if(Judge(codelen, Weight, N)) printf("Yes
");
        else printf("No
");
    }
    
    return 0;
}

 /* 建树结点 */
Tree NewTreeNode() {
    Tree T;
    T = (Tree)malloc(sizeof(struct TreeNode));
    T->Weight = 0;
    T->Left = T->Right = NULL;    
    return T;
}

 /* 建空堆 */
Heap CreatHeap() {
    Heap H;
    H = (Heap)malloc(sizeof(struct HeapNode));
    H->Size = 0;            /* 空堆 */
    H->Data[0].Weight = -1; /* 哨兵 */
    return H;
}
 
 /* 堆插入 */
void Insert(Heap H, struct TreeNode T) {
    int i = ++H->Size;  /* ++堆, 从堆的最后开始寻找插入结点位置 */
    for( ; T.Weight < H->Data[i/2].Weight; i /= 2)
        H->Data[i] = H->Data[i/2]; /* 父结点下滤 */
    H->Data[i] = T; /* 插入结点 */
}

 /* 堆删除 */
Tree Delete(Heap H) 
{    /* 提取堆最后一个树结点, 从堆的第一个结点开始比较,上滤, 堆-- */
    int parent, child;
    struct TreeNode Temp = H->Data[H->Size--]; /* 提取堆最后一个树结点 */
    Tree T = NewTreeNode(); /* 创建树结点 */
    *T = H->Data[1];        /* 从堆中提取第一个树结点 */
    for(parent = 1; 2*parent <= H->Size; parent = child) 
    {
        child = 2 * parent; /* 从父结点找左孩子 */
        if(child != H->Size && H->Data[child].Weight > H->Data[child+1].Weight) 
            child++;        /* 有右孩子且比左孩子小, 选右孩子 */
        if(Temp.Weight < H->Data[child].Weight) 
            break;  /* 原堆最后一个树结点找到位置 */
        H->Data[parent] = H->Data[child]; /* 孩子结点上滤, 孩子结点覆盖父结点 */
    }
    H->Data[parent] = Temp; /* 原堆最后一个树结点归位 */
    return T; /* 返回原堆第一个树结点 */
}

/* 建Huffman树 */
Tree Huffman(Heap H) 
{   
    Tree T = NewTreeNode(); /* 临时树结点 */
    while(H->Size != 1) 
    {    /* 每次取堆中2个最小值建中间树结点 */
        T->Left = Delete(H);  
        T->Right = Delete(H);
        T->Weight = T->Left->Weight + T->Right->Weight;
        
        Insert(H, *T); /* 复制创建的中间树结点(传参)插入堆 */
    }
    free(T); /* 释放临时结点 */
    T = Delete(H); /* 取出堆中的树 */
    return T;
}
 
/* 带权路径长度 */
int WPL(Tree T, int Depth) { /* 整棵树的WPL */
    if(!T->Left && !T->Right) {  return Depth*T->Weight; }
    else return WPL(T->Left, Depth+1) + WPL(T->Right, Depth+1);
}

/* 判断是否正确的Huffman编码 */
int Judge(int codelen, int Weight[], int N) 
{
    int i, j, wgh; /* 权重wgh*/
    int flag = 1, count = 1; /* 前缀码, 结点个数 */
    char ch[2], s[MAXSIZE];     /* 叶结点 编码*/
    
    Tree T = NewTreeNode(), t = NULL; /* 树根 */
    
    /* 建树*/
    for(i = 0; i < N; i++)  /* N个叶子  */
    {
        t = T; /* 树根 */
        scanf("%s%s", ch, s); /* 叶结点 编码*/
        
        wgh = Weight[ch[0]];  /* 叶结点的权重    */    
                            
        for(j = 0; s[j]; j++)/* 由根向叶子建一枝树 */
        {
            if(s[j] == '0') {
                if(!t->Left){
                    t->Left = NewTreeNode();
                    count++;
                } 
                t = t->Left;            
            }
            if(s[j] == '1') {
                if(!t->Right){
                    t->Right = NewTreeNode();
                    count++;
                } 
                t = t->Right;            
            }                        
        }
        
        if(t->Left || t->Right){/*不是前缀码*/
            flag = 0;
        }                        
        else{
            t->Weight = wgh;
        }                        
    }
    
    /* 前缀码, 结点数, 带权路径长度 */
    if(!flag || count != 2*N-1 ||codelen != WPL(T, 0)) 
        return 0;
    return 1;
}

/* 
    建一个最小堆, 堆插入树结点, 形成树结点森林;
    每次从堆中取2个最小树结点, 建中间树结点并插入堆;
    最后堆中森林形成一棵Huffman树并计算WPL; 
    判断给定的叶结点及编码, 是否为正确的编码;
*/

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

/* 二叉树结点 */
typedef struct TreeNode* Tree;
struct TreeNode {
    int Weight;
    Tree Left, Right;
};

/* 堆(优先队列) */
#define MAXSIZE 256 
typedef struct HeapNode* Heap;
struct HeapNode {   
    struct TreeNode Data[MAXSIZE];/* 完全二叉树顺序存储 */
    int Size;
};
 
Tree NewTreeNode();/* 建树结点 */
Heap CreatHeap(); /* 建空堆 */
void Insert(Heap H, struct TreeNode T);/* 堆插入 */
Tree Delete(Heap H);/* 堆删除 */
Tree Huffman(Heap H); /* 建Huffman树 */
int WPL(Tree T, int Depth);/* 整棵树的WPL */

int cnt1 = 0, cnt2 = 0;  /* 结点度为1度为2的全局变量 */
void JudgeTree(Tree T); /* 判断树是否有度为1的结点 */
int Judge(int codelen, int Weight[], int N) ; /* 判断是否正确的Huffman编码 */

int main() 
{
    int N, Weight[MAXSIZE] = {0};
    char ch;
   
    Heap H = CreatHeap(); /* 建空堆 */
    Tree T = NewTreeNode();  /* 建临时树结点 */
    
    scanf("%d", &N);  /* 树结点个数 */
    for(int i = 0; i < N; i++) 
    {   
        scanf(" %c", &ch);    
        scanf("%d", &Weight[ch]);    
        T->Weight = Weight[ch];
        H->Data[H->Size].Left = H->Data[H->Size].Right = NULL;       
        Insert(H, *T); /* 复制创建的树结点(传参), 插入堆, 形成树森林 */
    }
    
    free(T); /* 释放临时结点 */
    
    T = Huffman(H);   /* 建Huffman树  */
    
    int codelen = WPL(T, 0); /* 求Huffman树的WPL */    
    int M;  /* M棵树 */
    scanf("%d", &M);
    
    while(M--) 
    {    /* 一次判断一棵树 */
        if(Judge(codelen, Weight, N)) printf("Yes
");
        else printf("No
");
    }
    
    return 0;
}

 /* 建树结点 */
Tree NewTreeNode() {
    Tree T;
    T = (Tree)malloc(sizeof(struct TreeNode));
    T->Weight = 0;
    T->Left = T->Right = NULL;    
    return T;
}

 /* 建空堆 */
Heap CreatHeap() {
    Heap H;
    H = (Heap)malloc(sizeof(struct HeapNode));
    H->Size = 0;            /* 空堆 */
    H->Data[0].Weight = -1; /* 哨兵 */
    return H;
}
 
 /* 堆插入 */
void Insert(Heap H, struct TreeNode T) {
    int i = ++H->Size;  /* ++堆, 从堆的最后开始寻找插入结点位置 */
    for( ; T.Weight < H->Data[i/2].Weight; i /= 2)
        H->Data[i] = H->Data[i/2]; /* 父结点下滤 */
    H->Data[i] = T; /* 插入结点 */
}

 /* 堆删除 */
Tree Delete(Heap H) 
{    /* 提取堆最后一个树结点, 从堆的第一个结点开始比较,上滤, 堆-- */
    int parent, child;
    struct TreeNode Temp = H->Data[H->Size--]; /* 提取堆最后一个树结点 */
    Tree T = NewTreeNode(); /* 创建树结点 */
    *T = H->Data[1];        /* 从堆中提取第一个树结点 */
    for(parent = 1; 2*parent <= H->Size; parent = child) 
    {
        child = 2 * parent; /* 从父结点找左孩子 */
        if(child != H->Size && H->Data[child].Weight > H->Data[child+1].Weight) 
            child++;        /* 有右孩子且比左孩子小, 选右孩子 */
        if(Temp.Weight < H->Data[child].Weight) 
            break;  /* 原堆最后一个树结点找到位置 */
        H->Data[parent] = H->Data[child]; /* 孩子结点上滤, 孩子结点覆盖父结点 */
    }
    H->Data[parent] = Temp; /* 原堆最后一个树结点归位 */
    return T; /* 返回原堆第一个树结点 */
}

/* 建Huffman树 */
Tree Huffman(Heap H) 
{   
    Tree T = NewTreeNode(); /* 临时树结点 */
    while(H->Size != 1) 
    {    /* 每次取堆中2个最小值建中间树结点 */
        T->Left = Delete(H);  
        T->Right = Delete(H);
        T->Weight = T->Left->Weight + T->Right->Weight;
        
        Insert(H, *T); /* 复制创建的中间树结点(传参)插入堆 */
    }
    free(T); /* 释放临时结点 */
    T = Delete(H); /* 取出堆中的树 */
    return T;
}
 
/* 带权路径长度 */
int WPL(Tree T, int Depth) { /* 整棵树的WPL */
    if(!T->Left && !T->Right) {  return Depth*T->Weight; }
    else return WPL(T->Left, Depth+1) + WPL(T->Right, Depth+1);
}

/* 判断树是否存在度为1的结点 */
void JudgeTree(Tree T) 
{
    if(T) {
        if(T->Left && T->Right) cnt2++;
        else if(!T->Left && !T->Right) cnt1++;
        else cnt1 = 0; /* 判断是否存在度为1的结点 */
        JudgeTree(T->Left);
        JudgeTree(T->Right);
    }
}

/* 判断是否正确的Huffman编码 */
int Judge(int codelen, int Weight[], int N) 
{
    int i, j, wgh, flag = 1;  /* 编码正确标志flag */
    char ch[2], s[MAXSIZE];    
    Tree T = NewTreeNode(), t = NULL;
    /* 1.建树(2个情况) */
    for(i = 0; i < N; i++)  /* N个叶子  */
    {
        t = T; /* 树根 */
        scanf("%s%s", ch, s); 
        wgh = Weight[ch[0]];
        
        /* 1.1. 树高超过了结点数*/        
        if(strlen(s) > N) { 
            flag = 0;
            break; 
        }
        
        /* 1.2. 由根向叶子建树 */            
        for(j = 0; s[j]; j++) 
        {
            if(s[j] == '0') {
                if(!t->Left) t->Left = NewTreeNode();
                t = t->Left;
            }
            if(s[j] == '1') {
                if(!t->Right) t->Right = NewTreeNode();
                t = t->Right;
            }
            
            if(!s[j+1]) /* 叶结点权重  */
            {    
                if(t->Left || t->Right)/*不是前缀码*/
                {   
                    flag = 0;
                    break; 
                }                    
                t->Weight = wgh;
            }
        }
    }
    
    /* 1.树高超过了结点数或不是前缀码*/
    if(!flag) 
        return 0;
    
    /* 2.判断是否存在度为1的结点 */
    cnt1 = cnt2 = 0;
    JudgeTree(T);
    if(cnt1 != cnt2 + 1) 
        return 0;
    
    /* 3.带权路径长度WPL是否相等*/
    if(codelen != WPL(T, 0)) 
        return 0; 
    
    /* 4.编码正确 */
    return 1;
}

/* 
    编码的字符是双数个，而提交采用的是等长编码
    仅判断叶结点和度的算法 测试点5不过
    需要判断用例与Huffman树的WPL是否相等
*/

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

#define MAXSIZE 256 

/* 二叉树结点 */
typedef struct TreeNode* Tree;
struct TreeNode {
    int Weight;
    Tree Left, Right;
};

Tree NewTreeNode();/* 建树结点 */

int cnt1 = 0, cnt2 = 0;  /* 结点度为1度为2的全局变量 */
void JudgeTree(Tree T); /* 判断树是否有度为1的结点 */
int Judge(int Weight[], int N) ; /* 判断是否正确的Huffman编码 */

int main() 
{
    int N, Weight[MAXSIZE] = {0};
    char ch;
       
    scanf("%d", &N);  /* 树结点个数 */
    for(int i = 0; i < N; i++) 
    {   
        scanf(" %c", &ch);    
        scanf("%d", &Weight[ch]);    
    }
    
    int M;  /* M棵树 */
    scanf("%d", &M);
    
    while(M--) 
    {    /* 一次判断一棵树 */
        if(Judge(Weight, N)) printf("Yes
");
        else printf("No
");
    }
    
    return 0;
}

 /* 建树结点 */
Tree NewTreeNode() {
    Tree T;
    T = (Tree)malloc(sizeof(struct TreeNode));
    T->Weight = 0;
    T->Left = T->Right = NULL;    
    return T;
}

/* 判断树是否存在度为1的结点 */
void JudgeTree(Tree T) 
{
    if(T) {
        if(T->Left && T->Right) cnt2++;
        else if(!T->Left && !T->Right) cnt1++;
        else cnt1 = 0; 
        JudgeTree(T->Left);
        JudgeTree(T->Right);
    }
}

int Judge(int Weight[], int N) 
{
    int i, j, wgh, flag = 1;  /* 编码正确标志flag */
    char ch[2], s[MAXSIZE];    
    Tree T = NewTreeNode(), t = NULL;
    /* 1.建树(2个情况) */
    for(i = 0; i < N; i++)  /* N个叶子  */
    {
        t = T; /* 树根 */
        scanf("%s%s", ch, s); 
        wgh = Weight[ch[0]];
        
        /* 1.1. 树高超过了结点数*/        
        if(strlen(s) > N) { 
            flag = 0;
            break; 
        }
        
        /* 1.2. 由根向叶子建树 */            
        for(j = 0; s[j]; j++) 
        {
            if(s[j] == '0') {
                if(!t->Left) t->Left = NewTreeNode();
                t = t->Left;
            }
            if(s[j] == '1') {
                if(!t->Right) t->Right = NewTreeNode();
                t = t->Right;
            }
            
            if(!s[j+1]) /* 叶结点权重  */
            {    
                if(t->Left || t->Right)/*不是前缀码*/
                {   
                    flag = 0;
                    break; 
                }                    
                t->Weight = wgh;
            }
        }
    }
    
    /* 1.树高超过了结点数或不是前缀码*/
    if(!flag) 
        return 0;
    
    /* 2.判断是否存在度为1的结点 */
    cnt1 = cnt2 = 0;
    JudgeTree(T);
    if(cnt1 != cnt2 + 1) 
        return 0;
    
    /* 3.编码正确 */
    return 1;
}

06-图1 列出连通集

给定一个有N个顶点和E条边的无向图，请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时，假设我们总是从编号最小的顶点出发，按编号递增的顺序访问邻接点。

输入格式:

输入第1行给出2个整数N(0<N≤10)和E，分别是图的顶点数和边数。随后E行，每行给出一条边的两个端点。每行中的数字之间用1空格分隔。

输出格式:

按照"{ v₁v₂... v_k}"的格式，每行输出一个连通集。先输出DFS的结果，再输出BFS的结果。

输入样例:

8 6
0 7
0 1
2 0
4 1
2 4
3 5

输出样例:

{ 0 1 4 2 7 }
{ 3 5 }
{ 6 }
{ 0 1 2 7 4 }
{ 3 5 }
{ 6 }

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

/* 定义图 */
#define MaxVertex 100        /* 顶点个数 */
typedef int Vertex;          /* 顶点类型定义 */
int G[MaxVertex][MaxVertex]; /* 图的邻接矩阵 */
int Nv, Ne;                  /* 图的顶点及边 */
bool visit[MaxVertex];       /* 顶点是否访问数组标记 */

/* 队列结构体(顺序队列) */
#define ERROR -1
typedef struct QNode *Queue;
struct QNode {
    Vertex *Data;     /* 存储元素的数组 */
    int Front, Rear;  /* 队列的头、尾指针 */
    int MAXSIZE;           /* 队列最大容量 */
};

Queue CreateQueue();
bool IsFull( Queue Q );
bool AddQ( Queue Q, Vertex X );
bool IsEmpty( Queue Q );
Vertex DeleteQ( Queue Q );

void BuildGraph();       /* 建图  */
void DFS(Vertex v); /* DFS */
void BFS(Vertex v); /* BFS */
void PrintConnectedSet(void(*Traverse)(Vertex));  /* 遍历联通集  */

int main()
{
    BuildGraph();
    PrintConnectedSet(DFS);
    PrintConnectedSet(BFS);
    return 0;
} 

Queue CreateQueue()
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (Vertex *)malloc(MAXSIZE * sizeof(Vertex));
    Q->Front = Q->Rear = 0;
    Q->MAXSIZE = MaxVertex;
    return Q;
}
 
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MAXSIZE == Q->Front);
}
 
bool AddQ( Queue Q, Vertex X )
{
    if ( IsFull(Q) ) {     
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MAXSIZE;
        Q->Data[Q->Rear] = X;
        return true;
    }
}
 
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}
 
Vertex DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MAXSIZE;
        return  Q->Data[Q->Front];
    }
}

/* 建图  */
void BuildGraph()
{
    scanf("%d", &Nv);
    for(int i=0; i<Nv; ++i)
    {
        visit[i] = false;  /* 图的顶点置为未访问  */
        for(int j=0; j<Nv; j++)
            G[i][j] = 0;   /* 图的顶点之间置为未连接 */        
    }
    scanf("%d", &Ne);       /* 输入图的边, 顶点对 */
    for(int i=0; i<Ne; i++)
    {
        Vertex v1, v2;
        scanf("%d%d", &v1, &v2);
        G[v1][v2] = 1;
        G[v2][v1] = 1;      /* 无向图 */
    }
}

/* DFS */
void DFS(Vertex v)
{ 
    visit[v] = true; /* 标记已访问 */
    printf(" %d", v);
    for(Vertex i=0; i<Nv; i++) /* 与该顶点邻接的顶点 */
        if(!visit[i] && G[v][i])
            DFS(i);
} 

/* BFS */
void BFS(Vertex v)
{
    Queue q = CreateQueue(); /* 建队列     */
    visit[v] = true;         /* 访问顶点 */
    printf(" %d", v);    
    AddQ(q,v);               /* 顶点入队  */
    while(!IsEmpty(q))
    {        
        Vertex t = DeleteQ(q); /* 出队队首元素 */ 
        for(Vertex i=0; i<Nv; ++i) /* 与该顶点邻接的顶点 */
        {            
            if(!visit[i] && G[t][i]) /* 未访问的邻接顶点 */
            {
                visit[i] = true; /* 访问顶点 */
                printf(" %d", i);    
                AddQ(q,i);       /* 顶点入队  */
            }
        }
    }
}

/* 遍历联通集  */
void PrintConnectedSet(void(*Traverse)(Vertex))
{
    for(Vertex i=0; i<Nv; ++i) /*遍历顶点 */
    {
        if(!visit[i]){
            printf("{");
            Traverse(i); /* DFS, BFS */
            printf(" }
");
        }
    }
    for(Vertex i=0;i<Nv;i++) /* 顶点恢复未访问  */
        visit[i] = false;
}        

06-图2 Saving James Bond - Easy Version

This time let us consider the situation in the movie "Live and Let Die" in which James Bond, the world's most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape -- he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head... Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).

Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him whether or not he can escape.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integers N (≤100), the number of crocodiles, and D, the maximum distance that James could jump. Then N lines follow, each containing the (x,y) location of a crocodile. Note that no two crocodiles are staying at the same position.

Output Specification:

For each test case, print in a line "Yes" if James can escape, or "No" if not.

Sample Input 1:

14 20
25 -15
-25 28
8 49
29 15
-35 -2
5 28
27 -29
-8 -28
-20 -35
-25 -20
-13 29
-30 15
-35 40
12 12

Sample Output 1:

Yes

Sample Input 2:

4 13
-12 12
12 12
-12 -12
12 -12

Sample Output 2:

No

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

/* 鳄鱼结点 */
#define MaxVertexNum 101
struct Node{  
    int x;    /* 横坐标 */
    int y;    /* 纵坐标 */
    bool visit;       /* 是否被访问 */
    bool toshore;     /* 是否能上岸  */
};

int N;    /* 鳄鱼数 */ 
int D;    /* 跳跃距离 */
struct Node G[MaxVertexNum]; /* 鳄鱼图 */
bool Escape = false; /* 逃离 */

void Init();/* 图初始化 */ 
bool Shore(int x, int y, double d); /* 能否到岸 */
bool Jump(int x1, int y1, int x2, int y2, double d); /* 能否跳上去 */
void DFS(int v);  /* 深搜 */
void listCompoent();/* 遍历所有第一步能跳到的鳄鱼  */

int main()
{
    Init();
    listCompoent();
    return 0;
}

void Init()
{
    scanf("%d%d", &N, &D);
    int x,y;
    for(int i=0;i<N;i++)
    {
        scanf("%d%d", &x, &y);
        G[i].x = x;
        G[i].y = y;
        G[i].visit = false;
        G[i].toshore = false;
        if(Shore(x,y,D)) G[i].toshore = true;                
    }
}

bool Shore(int x, int y, double d){
    return abs(x-50)<=d || abs(x+50)<=d || abs(y+50)<=d || abs(y-50) <= d;
}

bool Jump(int x1, int y1, int x2, int y2, double d){
    return sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)) <= d;
}

void DFS(int v)
{
    if(G[v].toshore){         
        Escape = true;
        return;
    } 
    G[v].visit = true;
    for(int i=0; i<N; i++){  /* 没被访问且可以跳上去的鳄鱼v to i */
        if(!G[i].visit && Jump(G[v].x, G[v].y, G[i].x, G[i].y, D))
            DFS(i);
    }
}

void listCompoent()
{
    for(int i=0; i<N; i++)
    {
        if(Jump(G[i].x, G[i].y, 0, 0, D+15/2)) /* first jump */
        {
            DFS(i);        
        }
    }        
    if(Escape)
        printf("Yes
");
    else
        printf("No
");
}

06-图3 六度空间

“六度空间”理论又称作“六度分隔（Six Degrees of Separation）”理论。这个理论可以通俗地阐述为：“你和任何一个陌生人之间所间隔的人不会超过六个，也就是说，最多通过五个人你就能够认识任何一个陌生人。”如图所示。

 

“六度空间”理论虽然得到广泛的认同，并且正在得到越来越多的应用。但是数十年来，试图验证这个理论始终是许多社会学家努力追求的目标。然而由于历史的原因，这样的研究具有太大的局限性和困难。随着当代人的联络主要依赖于电话、短信、微信以及因特网上即时通信等工具，能够体现社交网络关系的一手数据已经逐渐使得“六度空间”理论的验证成为可能。

 假如给你一个社交网络图，请你对每个节点计算符合“六度空间”理论的结点占结点总数的百分比。

输入格式:

输入第1行给出两个正整数，分别表示社交网络图的结点数N（1<N≤10³，表示人数）、边数M（≤33×N，表示社交关系数）。随后的M行对应M条边，每行给出一对正整数，分别是该条边直接连通的两个结点的编号（节点从1到N编号）。

输出格式:

对每个结点输出与该结点距离不超过6的结点数占结点总数的百分比，精确到小数点后2位。每个结节点输出一行，格式为“结点编号:（空格）百分比%”。

输入样例:

10 9
1 2
2 3
3 4
4 5
5 6
6 7
7 8
8 9
9 10

输出样例:

1: 70.00%
2: 80.00%
3: 90.00%
4: 100.00%
5: 100.00%
6: 100.00%
7: 100.00%
8: 90.00%
9: 80.00%
10: 70.00%

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

/* 邻接表结点 */
#define MaxVertex 10005
typedef int Vertex;
typedef struct Node *AdjList;
struct Node{
    Vertex Adjv;   /* 顶点 */
    AdjList Next;  
};

AdjList G[MaxVertex];    /* 邻接表数组 */
bool visit[MaxVertex];   /* 是否访问 */ 
int N;   /* 结点数 */
int M;   /* 边数  */

/* 队列结构体(顺序队列) */
#define ERROR -1
typedef struct QNode *Queue;
struct QNode {
    Vertex *Data;     /* 存储元素的数组 */
    int Front, Rear;  /* 队列的头、尾指针 */
    int MAXSIZE;           /* 队列最大容量 */
};

Queue CreateQueue();
bool IsFull( Queue Q );
bool AddQ( Queue Q, Vertex X );
bool IsEmpty( Queue Q );
Vertex DeleteQ( Queue Q );

void InitVisit(); /* 访问状态初始值 */
void Init(); /* 初始化  */
int BFS(Vertex v);
void output(double result,int i);
void SDS();

int main()
{
    Init();
    SDS();    
    return 0;
} 

Queue CreateQueue()
{
    Queue Q = (Queue)malloc(sizeof(struct QNode));
    Q->Data = (Vertex *)malloc(MaxVertex * sizeof(Vertex));
    Q->Front = Q->Rear = 0;
    Q->MAXSIZE = MaxVertex;
    return Q;
}
 
bool IsFull( Queue Q )
{
    return ((Q->Rear+1)%Q->MAXSIZE == Q->Front);
}
 
bool AddQ( Queue Q, Vertex X )
{
    if ( IsFull(Q) ) {     
        return false;
    }
    else {
        Q->Rear = (Q->Rear+1)%Q->MAXSIZE;
        Q->Data[Q->Rear] = X;
        return true;
    }
}
 
bool IsEmpty( Queue Q )
{
    return (Q->Front == Q->Rear);
}
 
Vertex DeleteQ( Queue Q )
{
    if ( IsEmpty(Q) ) { 
        return ERROR;
    }
    else  {
        Q->Front =(Q->Front+1)%Q->MAXSIZE;
        return  Q->Data[Q->Front];
    }
}

void InitVisit(){ /* 访问状态初始值 */
    for(int i=1; i<=N; ++i)
        visit[i] = false;
}

void Init() /* 初始化  */
{
    Vertex v1,v2;
    AdjList NewNode;
    scanf("%d%d", &N, &M);
    
    for(int i=1; i<=N; ++i){  /* 邻接表初始化 1—N */
        G[i] = (AdjList)malloc(sizeof(struct Node));
        G[i]->Adjv = i;     /* 邻接表下标 */
        G[i]->Next = NULL;  /* 邻接表指针 */
    }

    for(int i=0; i<M; ++i){  /* 边初始值 */
        scanf("%d%d", &v1, &v2);
        
        NewNode = (AdjList)malloc(sizeof(struct Node));
        NewNode->Adjv = v2;         /* 新结点 */
        
        NewNode->Next = G[v1]->Next; /* 链接 */
        G[v1]->Next = NewNode;  
        
        NewNode = (AdjList)malloc(sizeof(struct Node));
        NewNode->Adjv = v1;          /* 新结点 */
        
        NewNode->Next = G[v2]->Next; /* 链接 */
        G[v2]->Next = NewNode;       
    }
}

int BFS(Vertex v)
{
    Queue q = CreateQueue();
    Vertex t;
    int level = 0;
    int last = v;     /* 该层最后一次访问的结点 */ 
    int tail = v;     /* 每次在变的结点 */ 
    AdjList node;     /* 邻接表结点 */
    visit[v] = true;
    int count = 1;    /* 统计关系数 */ 
    AddQ(q,v);        /* 顶点入队 */
    while(!IsEmpty(q))
    {
        t = DeleteQ(q);   /* 顶点出队 */

        node = G[t]->Next; /* G[i]第一个结点存自己的下标  */
        while(node)
        {
            if(!visit[node->Adjv]){
                visit[node->Adjv] = true;
                AddQ(q, node->Adjv);
                count++;
                tail = node->Adjv; /* 每次更新该结点  */
            }
            node = node->Next;
        } 
    
        if(t == last){  /* 如果该当前结点是这层最后一个结点  */
            level++;      /* 层数 +1 */  
            last = tail;  /* 更改 last  */
        }
        
        if(level==6)  /* 6层结束  */
           break;
    }
    return count; 
} 


void output(double result, int i){
    printf("%d: %.2f%%
", i, result);
}

void SDS()  /* 六度空间搜索 six degree search */
{
    int count;
    for(int i=1; i<=N; i++){
        InitVisit();     /* 每次初始化访问数组  */
        count = BFS(i);   /* 搜索结果, 结点数count */
        output((100.0*count)/N, i);
    }
}

07-图4 哈利·波特的考试

哈利·波特要考试了，他需要你的帮助。这门课学的是用魔咒将一种动物变成另一种动物的本事。例如将猫变成老鼠的魔咒是haha，将老鼠变成鱼的魔咒是hehe等等。反方向变化的魔咒就是简单地将原来的魔咒倒过来念，例如ahah可以将老鼠变成猫。另外，如果想把猫变成鱼，可以通过念一个直接魔咒lalala，也可以将猫变老鼠、老鼠变鱼的魔咒连起来念：hahahehe。

现在哈利·波特的手里有一本教材，里面列出了所有的变形魔咒和能变的动物。老师允许他自己带一只动物去考场，要考察他把这只动物变成任意一只指定动物的本事。于是他来问你：带什么动物去可以让最难变的那种动物（即该动物变为哈利·波特自己带去的动物所需要的魔咒最长）需要的魔咒最短？例如：如果只有猫、鼠、鱼，则显然哈利·波特应该带鼠去，因为鼠变成另外两种动物都只需要念4个字符；而如果带猫去，则至少需要念6个字符才能把猫变成鱼；同理，带鱼去也不是最好的选择。

输入格式:

输入说明：输入第1行给出两个正整数N (≤100)和M，其中N是考试涉及的动物总数，M是用于直接变形的魔咒条数。为简单起见，我们将动物按1~N编号。随后M行，每行给出了3个正整数，分别是两种动物的编号、以及它们之间变形需要的魔咒的长度(≤100)，数字之间用空格分隔。

输出格式:

输出哈利·波特应该带去考场的动物的编号、以及最长的变形魔咒的长度，中间以空格分隔。如果只带1只动物是不可能完成所有变形要求的，则输出0。如果有若干只动物都可以备选，则输出编号最小的那只。

输入样例:

6 11
3 4 70
1 2 1
5 4 50
2 6 50
5 6 60
1 3 70
4 6 60
3 6 80
5 1 100
2 4 60
5 2 80

输出样例:

4 70

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

#define MaxVertexNum 100 /* 最大顶点数设为100 */ 
#define INFINITY 65535   /* ∞设为双字节无符号整数的最大值65535*/ 
typedef int Vertex;      /* 用顶点下标表示顶点,为整型*/ 
typedef int WeightType;  /* 边的权值设为整型*/ 

/* 边的定义*/ 
typedef struct ENode* PtrToENode; 
struct ENode{ 
    Vertex V1, V2;      /* 有向边<V1, V2> */ 
    WeightType Weight;  /* 权重*/ 
}; 
typedef PtrToENode Edge; /* 边类型 边结构体指针 */

/* 图结点的定义*/ 
typedef struct GNode* PtrToGNode; 
struct GNode{ 
    int Nv;  /* 顶点数*/ 
    int Ne;  /* 边数*/ 
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵*/     
}; 
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 图结构体指针*/

MGraph CreateGraph( int VertexNum);/* 初始化一个有VertexNum个顶点但没有边的图*/  
void InsertEdge( MGraph Graph, Edge E );/* 插入边<V1, V2> */  
MGraph BuildGraph();  /* 1 */

void Floyd( MGraph Graph, WeightType D[][MaxVertexNum] ); /* 弗洛伊德算法 */
WeightType FindMaxDist( WeightType D[][MaxVertexNum], Vertex i, int N );
void FindAnimal( MGraph Graph ); /* 2 */

int main()
{
    MGraph G = BuildGraph(); 
    FindAnimal( G ); 
    return 0;
}

MGraph CreateGraph( int VertexNum) 
{ /* 初始化一个有VertexNum个顶点但没有边的图*/ 
    Vertex V, W;    /* 顶点V W */
    MGraph Graph;   /* 图指针 */
    Graph = (MGraph)malloc(sizeof(struct GNode)); /* 建立图*/ 
    Graph->Nv = VertexNum;  /* 图顶点数 */
    Graph->Ne = 0;          /* 没有边  */   
    /* 初始化邻接矩阵*/ 
    /* 注意：这里默认顶点编号从0开始，到(Graph->Nv-1) */ 
    for(V=0; V<Graph->Nv; V++) 
        for(W=0; W<Graph->Nv; W++)  
            Graph->G[V][W] = INFINITY;  /* 顶点之间没有边 */
    return Graph; 
}

void InsertEdge( MGraph Graph, Edge E ) /* 插入边<V1, V2> */  
{     /* 若是无向图，还要插入边<V2, V1> */ 
    Graph->G[E->V1][E->V2] = E->Weight; 
    Graph->G[E->V2][E->V1] = E->Weight; 
}

MGraph BuildGraph() 
{ 
    MGraph Graph; 
    Edge E; 
    int Nv, i;
    scanf("%d", &Nv);            /* 读入顶点个数*/ 
    Graph = CreateGraph(Nv);     /* 初始化有Nv个顶点但没有边的图*/
    scanf("%d", &(Graph->Ne));   /* 读入边数*/ 
    if( Graph->Ne != 0 ) {       /* 如果有边*/ 
        E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点*/ 
        /* 读入边，格式为"起点终点权重"，插入邻接矩阵*/ 
        for(i=0; i<Graph->Ne; i++) { 
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            E->V1--; E->V2--;  /* 起始编号从0开始 */
            InsertEdge( Graph, E ); 
        } 
    } 
    return Graph;
} 

void Floyd( MGraph Graph, WeightType D[][MaxVertexNum] ) 
{  
    Vertex i, j, k;
    /* 初始化*/ 
    for( i=0; i<Graph->Nv; i++ ) 
        for( j=0; j<Graph->Nv; j++ ) { 
            D[i][j] = Graph->G[i][j];             
        }
    for( k=0; k<Graph->Nv; k++ ) 
        for( i=0; i<Graph->Nv; i++ ) 
            for( j=0; j<Graph->Nv; j++ ) 
                if( D[i][k] + D[k][j] < D[i][j] ) { 
                    D[i][j] = D[i][k] + D[k][j]; 
                }
}

void FindAnimal( MGraph Graph ) 
{  
    WeightType D[MaxVertexNum][MaxVertexNum], MaxDist, MinDist; 
    Vertex Animal, i;
    
    Floyd( Graph, D ); /* 多源最短路径 */
    
    MinDist= INFINITY; 
    for( i=0; i<Graph->Nv; i++ ) { 
        MaxDist= FindMaxDist( D, i, Graph->Nv);  /* 第i行的最大值 */
        if( MaxDist== INFINITY ) { /* 说明有从i无法变出的动物*/ 
            printf("0
"); 
            return; 
        } 
        if( MinDist > MaxDist) { /* 找到最长距离更小的动物*/ 
            MinDist = MaxDist;  
            Animal = i+1; /* 更新距离，记录编号*/ 
        } 
    } 
    printf("%d %d
", Animal, MinDist);
}

WeightType FindMaxDist( WeightType D[][MaxVertexNum], Vertex i, int N ) 
{ 
    WeightType MaxDist; 
    Vertex j;
    MaxDist= 0; 
    for( j=0; j<N; j++ ) /* 找出i到其他动物j的最长距离*/ 
        if( i!=j && D[i][j]>MaxDist) /* i==j 对角元的值INFINITY  */
            MaxDist = D[i][j];   /* 第i行的最大值 */
    return MaxDist;
}

07-图5 Saving James Bond - Hard Version

This time let us consider the situation in the movie "Live and Let Die" in which James Bond, the world's most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape -- he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head... Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).

Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him a shortest path to reach one of the banks. The length of a path is the number of jumps that James has to make.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integers N (≤100), the number of crocodiles, and D, the maximum distance that James could jump. Then N lines follow, each containing the (x,y) location of a crocodile. Note that no two crocodiles are staying at the same position.

Output Specification:

For each test case, if James can escape, output in one line the minimum number of jumps he must make. Then starting from the next line, output the position (x,y) of each crocodile on the path, each pair in one line, from the island to the bank. If it is impossible for James to escape that way, simply give him 0 as the number of jumps. If there are many shortest paths, just output the one with the minimum first jump, which is guaranteed to be unique.

Sample Input 1:

17 15
10 -21
10 21
-40 10
30 -50
20 40
35 10
0 -10
-25 22
40 -40
-30 30
-10 22
0 11
25 21
25 10
10 10
10 35
-30 10

Sample Output 1:

4
0 11
10 21
10 35

Sample Input 2:

4 13
-12 12
12 12
-12 -12
12 -12

Sample Output 2:

0

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

/* 队列定义开始 */
#define MaxSize 101
int Queue[MaxSize];
int front = 0, rear = 0;
/* 队列定义结束 */

#define MaxVertexNum 100
#define INF 65535
#define ISLAND_DIAMETER 15/2.0

typedef struct Position Point;
struct Position {
    int x;
    int y;
};

Point points[MaxVertexNum]; /* 鳄鱼坐标 */
int dist[MaxVertexNum];     /* 路径长度 */
int path[MaxVertexNum];     /* 下一个结点 */

void ReadPoints(int num); /* 读取鳄鱼坐标 */

int Distance(Point p1, Point p2);    /* 求两点间距离 */
int Jump(Point p1, Point p2, int dis);  /* 判断能否跳跃过去 */
int isSafe(Point p, int dis);    /* 是否能跳上岸 */
void PrintPath(int ans);
void Save007(int num, int dis);  /* BFS函数 */

int main()
{
    int num, dis; /* num鳄鱼数 dis James可以跳的最远距离 */
    scanf("%d %d", &num, &dis);

    ReadPoints(num);   /* 读取鳄鱼坐标 */
    Save007(num, dis); /* 计算并输出 */

    return 0;
}

void ReadPoints(int num)
{
    int i;
    for (i = 0; i < num; ++i) {
        scanf("%d %d", &(points[i].x), &(points[i].y));
    }
}

int Distance(Point p1, Point p2)
{
    return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}

int Jump(Point p1, Point p2, int dis)
{
    return Distance(p1, p2) <= dis * dis;
}

int isSafe(Point p, int dis)
{
    return ((abs(p.x) + dis) >= 50 || (abs(p.y) + dis) >= 50);
}

void PrintPath(int ans)
{
    printf("%d
", dist[ans] + 1);
    for (; ans != -1; ans = path[ans]) {
        printf("%d %d
", points[ans].x, points[ans].y);
    }
}

void Save007(int num, int dis)
{
    int i, cur_dis, pIndex, ans;
    Point center;  /* 岛的中心位置 */
    center.x = 0; center.y = 0;

    /* 如果从岛上就能直接跳上岸 */
    if (isSafe(center, dis + ISLAND_DIAMETER)) {
        printf("1
");
        return;
    }

    for (i = 0; i < num; ++i) { /* 初始化辅助数组 */
        dist[i] = INF;
        path[i] = -1;
    }
    
    for (i = 0; i < num; ++i) {
        if (isSafe(points[i], dis)) {/* 将所有能上岸的入队 */
            dist[i] = 1;
            Queue[rear] = i;  /* 入队 */
            rear = (rear+1) % MaxSize;
        }
    }
    
    cur_dis = 1; ans = -1;
    while (front != rear) 
    {
        pIndex = Queue[front];    /* 出队 */
        front = (front+1) % MaxSize;
        
        if (dist[pIndex] == cur_dis + 1 && ans != -1) break;  /* 已经遍历完当前层 */
        if (Jump(center, points[pIndex], dis + ISLAND_DIAMETER)) {
            if (ans == -1 || Distance(center, points[pIndex]) < Distance(center, points[ans]))
                ans = pIndex;
        }
        else {
            for (i = 0; i < num; ++i) {
                if (Jump(points[pIndex], points[i], dis) && (dist[pIndex] + 1 < dist[i])) {
                    dist[i] = dist[pIndex] + 1;
                    path[i] = pIndex;
                    Queue[rear] = i;  /* 入队 */
                    rear = (rear+1) % MaxSize;
                }
            }
        }
        cur_dis = dist[pIndex];
    }
    if (ans == -1) printf("0
");
    else PrintPath(ans);
}

07-图6 旅游规划

有了一张自驾旅游路线图，你会知道城市间的高速公路长度、以及该公路要收取的过路费。现在需要你写一个程序，帮助前来咨询的游客找一条出发地和目的地之间的最短路径。如果有若干条路径都是最短的，那么需要输出最便宜的一条路径。

输入格式:

输入说明：输入数据的第1行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0~(N−1)；M是高速公路的条数；S是出发地的城市编号；D是目的地的城市编号。随后的M行中，每行给出一条高速公路的信息，分别是：城市1、城市2、高速公路长度、收费额，中间用空格分开，数字均为整数且不超过500。输入保证解的存在。

输出格式:

在一行里输出路径的长度和收费总额，数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

4 5 0 3
0 1 1 20
1 3 2 30
0 3 4 10
0 2 2 20
2 3 1 20

输出样例:

3 40

#include <stdio.h>
#include <stdbool.h>

#define INF 65535
#define MaxVertexNum 501

struct node{
    int E; /* 距离 */
    int C; /* 花费 */
};

typedef struct node Vertex;     /* 顶点 */
Vertex G[MaxVertexNum][MaxVertexNum];   /* 图 */

bool collected[MaxVertexNum];   /* 收录 */
int dist[MaxVertexNum];         /* 最近距离 */
int cost[MaxVertexNum];         /* 最少花费 */

int N;  /* 城市的编号为0~(N−1),顶点数 */
int M;    /* 高速公路的条数 */
int S;    /* 出发地的城市编号 */
int D;  /* 目的地的城市编号 */

/* 初始化  */
void Init()
{                
    scanf("%d%d%d%d", &N, &M, &S, &D);
        
    for(int i=0; i<N; i++)  /* N个城市 */
    { 
        for(int j=0; j<N; j++){/* 初始化图 */
            G[i][j].E = INF;    
            G[i][j].C = INF; 
            if(i==j){         /* 对角线距离花费 */
                G[i][j].E = 0; 
                G[i][j].C = 0; 
            } 
        }
        dist[i] = INF;        /* 初始化最近距离 INF*/
        cost[i] = 0;          /* 初始化最少花费 0 */
        collected[i] = false; /* 初始化收录集合 */
    }     
    
    int v1, v2;
    for(int i=0; i<M; i++){ /* M条路*/        
        scanf("%d%d", &v1, &v2);  /* 城市1、城市2 */
        /* 高速公路长度、收费额 */    
        scanf("%d%d", &G[v1][v2].E, &G[v1][v2].C);
        G[v2][v1].E = G[v1][v2].E;   /* 无向图 */
        G[v2][v1].C = G[v1][v2].C;
    }
}

/* 查找未收录dist最小的点 */
int FindMin( )
{
    int min = INF;
    int v = -1;
    for(int i=0; i<N; i++)
        if(!collected[i] && dist[i] < min)
        {
            min = dist[i];
            v = i;
        }
    return v;
} 

void Dijkstra( )
{ 
    dist[S] = 0; /* 起点本身的距离 */
    collected[S] = true;
    /* 起点的所有邻近城市最少距离和花费 */
    for (int V=0; V<N; V++ ) { 
        if(G[S][V].E){
            dist[V] = G[S][V].E;
            cost[V] = G[S][V].C;
        }     
    }
    /* 先将起点收入集合 */  
    while (1) 
    {
        int V = FindMin(  ); /* 查找未收录dist最小的点 */
        if ( -1 == V) break;            
        collected[V] = true;  /* 收录 */
        
        for(int W=0; W<N; W++)
        {
            if ( collected[W] == false )
            {    
                if ( dist[V]+G[V][W].E < dist[W] ) {
                    dist[W] = dist[V] + G[V][W].E ;                
                    cost[W] = cost[V] + G[V][W].C ;
                }
                /* 如果有若干条路径都是最短的 */
                /* 那么需要输出最便宜的一条路径 */
                else if ( (dist[V]+G[V][W].E == dist[W])
                    && (cost[V]+G[V][W].C < cost[W]) ){
                        cost[W] = cost[V] + G[V][W].C ;
                }
            }            
        }        
    }
}

int main()
{
    Init();
    Dijkstra();
    printf("%d %d", dist[D],cost[D]);
    return 0;
} 

08-图7 公路村村通

现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。

输入格式:

输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。

输出格式:

输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。

输入样例:

6 15
1 2 5
1 3 3
1 4 7
1 5 4
1 6 2
2 3 4
2 4 6
2 5 2
2 6 6
3 4 6
3 5 1
3 6 1
4 5 10
4 6 8
5 6 3

输出样例:

12

#include <stdio.h>

#define inf 65535
#define MAXN 1005
int map[MAXN][MAXN],distance[MAXN];
int N, M, count = 0, sum = 0;

void init() 
{
    for(int i = 1; i<=N; i++) {
        for(int j = 1; j<=N; j++) {
            map[i][j] = inf;
        }
    }
    int start,end,cost;
    for(int i = 0; i<M; i++) 
    { 
        scanf("%d%d%d",&start,&end,&cost);      
        map[start][end] = map[end][start] = cost;      
    }
}

void prim() 
{    /* 从1顶点出开始生成最小生成树 */
    for(int i = 2; i<=N; i++){
        distance[i] = map[1][i]; /* 顶点1到其他顶点的距离 */
    }
    distance[1] = -1; /* 代替顶点1,visited */
    int v = 1,MIN = inf;
    for(int i = 1; i<N; i++) 
    {
        MIN = inf,v = 1;
        for(int j = 1; j<=N; j++) 
        {/* 从没有访问过的顶点中找到下一个距离最短的边 */
            if(distance[j]>0 && distance[j]<MIN) {
                MIN = distance[j];
                v = j;
            }
        }
        if(MIN != inf)
        {
            sum += distance[v];
            distance[v] = -1; /* 代替visited */
            for(int j = 1; j<=N; j++) 
            {  /* 用这个最小的顶点的邻接边的权值更新distance[]的值 */
                if(map[v][j]<distance[j]) {
                    distance[j] = map[v][j];
                    count++;                    
                }
            }
        }   
    }
    
    if(count<N){    
        sum = -1;
    }
    printf("%d
",sum);        
}

int main() 
{
    scanf("%d%d",&N,&M);
    init();
    prim();
    return 0;
}

08-图8 How Long Does It Take

Given the relations of all the activities of a project, you are supposed to find the earliest completion time of the project.

Input Specification:

Each input file contains one test case. Each case starts with a line containing two positive integers N (≤100), the number of activity check points (hence it is assumed that the check points are numbered from 0 to N−1), and M, the number of activities. Then M lines follow, each gives the description of an activity. For the i-th activity, three non-negative numbers are given: S[i], E[i], and L[i], where S[i] is the index of the starting check point, E[i] of the ending check point, and L[i] the lasting time of the activity. The numbers in a line are separated by a space.

Output Specification:

For each test case, if the scheduling is possible, print in a line its earliest completion time; or simply output "Impossible".

Sample Input 1:

9 12
0 1 6
0 2 4
0 3 5
1 4 1
2 4 1
3 5 2
5 4 0
4 6 9
4 7 7
5 7 4
6 8 2
7 8 4

Sample Output 1:

18

Sample Input 1:

4 5
0 1 1
0 2 2
2 1 3
1 3 4
3 2 5

Sample Output 1:

Impossible

#include <stdio.h>

#define MaxVertex 105
#define INF -100000
typedef int Vertex;

int N;  /* 点 */
int M;  /* 边 */
int G[MaxVertex][MaxVertex];  
int Earliest[MaxVertex];  /* 时间  */
int Indegree[MaxVertex];  /* 入度  */

/* 初始化图  */
void build()
{
    Vertex v1,v2,w;
    scanf("%d%d", &N, &M);
    for(Vertex i=0; i<N; i++){
        for(Vertex j=0; j<N; j++)
            G[i][j] = INF;
    }
    for(int i=0;i<M;i++){
        scanf("%d%d%d", &v1,&v2,&w);
        G[v1][v2] = w;   /* 有向图  */
        Indegree[v2]++;  /* v2入度+1  */
    }
}

void TopSort()
{
    int cnt = 0;
    
    int queue[MaxVertex]; /* 队列 */
    int front = 0, rear = 0;
    
    for(Vertex i=0;i<N;i++)/* 入度为0顶点入队  */
        if(!Indegree[i]){ 
            queue[rear] = i;
            rear = (rear+1) % MaxVertex;
            Earliest[i] = 0;
        } 
    while(front != rear)
    {
        Vertex v = queue[front];
        front = (front+1) % MaxVertex;
        cnt++;
        for(Vertex w=0;w<N;w++)
        {
            if(G[v][w]!=INF) /* 邻接边 */
            { 
                if(Earliest[w] < Earliest[v]+G[v][w])
                {/* 如果周围有时间更长，更新时间  */
                    Earliest[w] = Earliest[v]+G[v][w];
                }                    
                if(--Indegree[w]==0)
                {
                    queue[rear] = w;
                    rear = (rear+1) % MaxVertex;
                }                    
            } 
        }            
    }
    if(cnt!=N)
        printf("Impossible");
    else{ /* 也许不止一个终点  */        
        int max = 0;
        for(Vertex i=0;i<N;i++)  
            if(max < Earliest[i]) 
                max = Earliest[i];
        printf("%d", max);
    }        
}

int main()
{
    build();
    TopSort();
    return 0;
}

08-图9 关键活动

假定一个工程项目由一组子任务构成，子任务之间有的可以并行执行，有的必须在完成了其它一些子任务后才能执行。“任务调度”包括一组子任务、以及每个子任务可以执行所依赖的子任务集。

比如完成一个专业的所有课程学习和毕业设计可以看成一个本科生要完成的一项工程，各门课程可以看成是子任务。有些课程可以同时开设，比如英语和C程序设计，它们没有必须先修哪门的约束；有些课程则不可以同时开设，因为它们有先后的依赖关系，比如C程序设计和数据结构两门课，必须先学习前者。

但是需要注意的是，对一组子任务，并不是任意的任务调度都是一个可行的方案。比如方案中存在“子任务A依赖于子任务B，子任务B依赖于子任务C，子任务C又依赖于子任务A”，那么这三个任务哪个都不能先执行，这就是一个不可行的方案。

任务调度问题中，如果还给出了完成每个子任务需要的时间，则我们可以算出完成整个工程需要的最短时间。在这些子任务中，有些任务即使推迟几天完成，也不会影响全局的工期；但是有些任务必须准时完成，否则整个项目的工期就要因此延误，这种任务就叫“关键活动”。

请编写程序判定一个给定的工程项目的任务调度是否可行；如果该调度方案可行，则计算完成整个工程项目需要的最短时间，并输出所有的关键活动。

输入格式:

输入第1行给出两个正整数N(≤100)和M，其中N是任务交接点（即衔接相互依赖的两个子任务的节点，例如：若任务2要在任务1完成后才开始，则两任务之间必有一个交接点）的数量。交接点按1~N编号，M是子任务的数量，依次编号为1~M。随后M行，每行给出了3个正整数，分别是该任务开始和完成涉及的交接点编号以及该任务所需的时间，整数间用空格分隔。

输出格式:

如果任务调度不可行，则输出0；否则第1行输出完成整个工程项目需要的时间，第2行开始输出所有关键活动，每个关键活动占一行，按格式“V->W”输出，其中V和W为该任务开始和完成涉及的交接点编号。关键活动输出的顺序规则是：任务开始的交接点编号小者优先，起点编号相同时，与输入时任务的顺序相反。

输入样例:

7 8
1 2 4
1 3 3
2 4 5
3 4 3
4 5 1
4 6 6
5 7 5
6 7 2

输出样例:

17
1->2
2->4
4->6
6->7

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

#define maxn 110 
#define INF 65535

int map[maxn][maxn];
int indegree[maxn],outdegree[maxn];
int earliest[maxn],latest[maxn];

void init(int n)
{
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= n; j++){
            map[i][j] = -1;
        }
        indegree[i] = 0;
        outdegree[i] = 0;
        earliest[i] = 0;
        latest[i] = INF;
    }
}

int max(int a,int b){
    return a > b ? a : b;
}

int min(int a,int b){
    return a < b ? a : b;
}

int early_time(int n)
{
    int* queue = (int*)malloc(n*sizeof(int));
    int front = -1, rear = -1;
    for(int i = 1; i <= n; i++){
        if(indegree[i] == 0){
            queue[++rear] = i;
        }
    }
    int cnt = 0;
    while(front < rear)
    {
        int v = queue[++front];
        cnt++;
        for(int i = 1; i <= n; i++){
            if(map[v][i] >= 0)
            {
                indegree[i]--;
                earliest[i] = max(earliest[i],earliest[v]+map[v][i]);
                if(indegree[i] == 0){
                    queue[++rear] = i;
                }
            }
        }
    }
    int ans = 0;
    if(cnt != n) ans = -1;
    else{
        ans = earliest[0];
        for(int i = 1; i <= n; i++){
            if(ans < earliest[i]) ans = earliest[i];
        }
    }
    return ans;
}

void late_time(int n,int x)
{
    int* queue = (int*)malloc(n*sizeof(int));
    int front = -1,rear = -1;
    for(int i = n; i >= 1; i--){
        if(outdegree[i] == 0){
            queue[++rear] = i;
            latest[i] = x;
        }
    }
    while(front < rear){
        int v = queue[++front];
        for(int i = n; i >= 1; i--){
            if(map[i][v] >= 0){ /* 邻接边 */
                outdegree[i]--;
                latest[i] = min(latest[i],latest[v]-map[i][v]);
                if(outdegree[i] == 0){
                    queue[++rear] = i;
                }
            }
        }
    }
}

int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    init(n); /* 初始化, n个任务交接点 */
    
    int v,u,w; /* m个子任务 */
    for(int i = 0; i < m; i++){
        scanf("%d%d%d",&u,&v,&w);
        map[u][v] = w;
        outdegree[u]++; /* 顶点的出度 */
        indegree[v]++;  /* 顶点的入度  */
    }
    
    int flag = early_time(n); /* 拓扑排序任务最早结束时间 */
    if(flag == -1) printf("0
");
    else{
        printf("%d
",flag);
        late_time(n,flag);    /* 拓扑排序任务最晚结束时间 */
        for(int i = 1; i <= n; i++)
        {
            if(earliest[i] != latest[i]) 
                continue;
            for(int j = n; j >= 1; j--)
            {
                if(map[i][j] >= 0 &&  /* 单起点和单终点，2条关键路径 */
                    earliest[j] == latest[j]&&  
                    (latest[j] - earliest[i] == map[i][j]))/* 多起点多终点 */
                        printf("%d->%d
",i,j); 
            }
        }
    }
    return 0;
}

09-排序1 排序

给定N个（长整型范围内的）整数，要求输出从小到大排序后的结果。

本题旨在测试各种不同的排序算法在各种数据情况下的表现。各组测试数据特点如下：

数据1：只有1个元素；

数据2：11个不相同的整数，测试基本正确性；

数据3：103个随机整数；

数据4：104个随机整数；

数据5：105个随机整数；

数据6：105个顺序整数；

数据7：105个逆序整数；

数据8：105个基本有序的整数；

数据9：105个随机正整数，每个数字不超过1000。

输入格式:

输入第一行给出正整数N（≤10⁵），随后一行给出N个（长整型范围内的）整数，其间以空格分隔。

输出格式:

在一行中输出从小到大排序后的结果，数字间以1个空格分隔，行末不得有多余空格。

输入样例:

11

4 981 10 -17 0 -20 29 50 8 43 -5

输出样例:

-20 -17 -5 0 4 8 10 29 43 50 981

#include <stdio.h>
#define MAXSIZE 100001

typedef int ElementType;
void Swap( ElementType *a, ElementType *b )
{
     ElementType t = *a; *a = *b; *b = t;
}
  
void PercDown( ElementType A[], int p, long N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
  /* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */
    long Parent, Child;
    ElementType X;
 
    X = A[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (A[Child]<A[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= A[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            A[Parent] = A[Child];
    }
    A[Parent] = X;
}
 
void HeapSort( ElementType A[], long N ) 
{ /* 堆排序 */
     long i;
       
     for ( i=N/2-1; i>=0; i-- )/* 建立最大堆 */
         PercDown( A, i, N );
      
     for ( i=N-1; i>0; i-- ) {
         /* 删除最大堆顶 */
         Swap( &A[0], &A[i] ); 
         PercDown( A, 0, i );
     }
}

int main()
{
    long N;
    int a[MAXSIZE] = {0};
    scanf("%ld", &N);
    for(long i=0; i<N; ++i){
        scanf("%d",&a[i]);
    }    
    HeapSort(a,N);
    for(long i=0; i<N; ++i){
        if(i) printf(" ");
        printf("%d",a[i]);
    }        
    return 0;
} 

09-排序2 Insert or Merge

According to Wikipedia:

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.

Merge sort works as follows: Divide the unsorted list into N sublists, each containing 1 element (a list of 1 element is considered sorted). Then repeatedly merge two adjacent sublists to produce new sorted sublists until there is only 1 sublist remaining.

Now given the initial sequence of integers, together with a sequence which is a result of several iterations of some sorting method, can you tell which sorting method we are using?

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤100). Then in the next line, N integers are given as the initial sequence. The last line contains the partially sorted sequence of the N numbers. It is assumed that the target sequence is always ascending. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in the first line either "Insertion Sort" or "Merge Sort" to indicate the method used to obtain the partial result. Then run this method for one more iteration and output in the second line the resuling sequence. It is guaranteed that the answer is unique for each test case. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input 1:

10

3 1 2 8 7 5 9 4 6 0

1 2 3 7 8 5 9 4 6 0

Sample Output 1:

Insertion Sort

1 2 3 5 7 8 9 4 6 0

Sample Input 2:

10

3 1 2 8 7 5 9 4 0 6

1 3 2 8 5 7 4 9 0 6

Sample Output 2:

Merge Sort

1 2 3 8 4 5 7 9 0 6

#include <stdio.h>
#include <stdbool.h>

bool judge(int A[],int B[],int N)
{
    for(int i=0;i<N;i++)
        if(A[i]!=B[i])
            return false;
    return true;
}

/* 插入排序  */
bool Insertion_Sort(int A[],int B[],int N)
{
    for(int P=1;P<N;P++)
    {
        int tmp = A[P];
        int j = P;
        for(;j>0 && tmp < A[j-1];j--)
            A[j] = A[j-1];
        A[j] = tmp;
        if(judge(A,B,N))
        {   /* 如果相等了，再做一轮 */ 
            P++;
            int tmp = A[P];
            int j = P;
            for(;j>0 && tmp < A[j-1];j--)
                A[j] = A[j-1];
            A[j] = tmp;
            return true;
        }
    }
    return false; 
}


void Merge(int A[],int tmpA[],int L,int R,int RightEnd)
{
    /* L = 左边起始位置，R = 右边起始位置，RightEnd = 右边终点位置  */
    int NumSize = RightEnd-L+1; /* 排序个数  */ 
    int LeftEnd = R-1;  /* 左边终止位置  */
    int tmp = L; 
    /* 排序 */ 
    while(L <= LeftEnd && R <= RightEnd){
        if(A[L] <= A[R])
            tmpA[tmp++] = A[L++];
        else
            tmpA[tmp++] = A[R++];
    } 
    /* 如果左边有剩  */
    while(L <= LeftEnd)
        tmpA[tmp++] = A[L++];
    /* 如果右边有剩  */
    while(R <= RightEnd)
        tmpA[tmp++] = A[R++];
    /* 导回 A 数组 */ 
    for(int i=0;i<NumSize;i++)
        A[RightEnd--] = tmpA[--tmp];
}

void Merge_pass(int A[],int tmpA[],int N,int length)
{
    int i;
    /* 每次 2*length 为一组排序单元 */ 
    for(i=0;i<=N-2*length;i+=2*length)
        Merge(A,tmpA,i,i+length,i+length*2-1);
    /* 处理剩下的不够一组的排序单元 */ 
    if(i+length < N)   /* 如果左边够了，但是右边不齐，再次进入排序  */
        Merge(A,tmpA,i,i+length,N-1);
    else   /* 如果左边都不够，直接导给 tmpA  */
        for(int j=i;j<N;j++)
            tmpA[j] = A[j];            
}

/* 归并排序 */
bool Merge_Sort(int A[],int B[],int N)
{
    int tmpA[N];
    int length = 1;
    while(length < N){
        Merge_pass(A,tmpA,N,length);  /* 一趟归并 */ 
        length *=2;
        if(judge(A,B,N)){  /* 如果相等了，再做一轮  */
            Merge_pass(A,tmpA,N,length);
            return true;
        }
    } 
    return false;
}

/* 输出  */
void output(int A[],int N)
{
    for(int i=0;i<N;i++){
        if(i)
            printf(" ");
        printf("%d", A[i]); 
    } 
} 

int main()
{
    int N;
    scanf("%d", &N);
    int A[N],tmpA[N];
    for(int i=0;i<N;i++){
        scanf("%d", &A[i]);
        tmpA[i] = A[i];
    }
    int B[N];
    for(int i=0;i<N;i++)
        scanf("%d", &B[i]);
    /* 用 tmpA 数组做归并排序，判断是否是归并排序  */
    if(Merge_Sort(tmpA,B,N)){
        printf("Merge Sort
");
        output(tmpA,N);
    }
    /* 用 A 数组做插入排序，判断是否是插入排序 */
    else if(Insertion_Sort(A,B,N)){
        printf("Insertion Sort
");
        output(A,N);
    }
    return 0;
}

09-排序3 Insertion or Heap Sort

According to Wikipedia:

Insertion sort iterates, consuming one input element each repetition, and growing a sorted output list. Each iteration, insertion sort removes one element from the input data, finds the location it belongs within the sorted list, and inserts it there. It repeats until no input elements remain.

Heap sort divides its input into a sorted and an unsorted region, and it iteratively shrinks the unsorted region by extracting the largest element and moving that to the sorted region. it involves the use of a heap data structure rather than a linear-time search to find the maximum.

Now given the initial sequence of integers, together with a sequence which is a result of several iterations of some sorting method, can you tell which sorting method we are using?

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤100). Then in the next line, N integers are given as the initial sequence. The last line contains the partially sorted sequence of the N numbers. It is assumed that the target sequence is always ascending. All the numbers in a line are separated by a space.

Output Specification:

For each test case, print in the first line either "Insertion Sort" or "Heap Sort" to indicate the method used to obtain the partial result. Then run this method for one more iteration and output in the second line the resulting sequence. It is guaranteed that the answer is unique for each test case. All the numbers in a line must be separated by a space, and there must be no extra space at the end of the line.

Sample Input 1:

10

3 1 2 8 7 5 9 4 6 0

1 2 3 7 8 5 9 4 6 0

Sample Output 1:

Insertion Sort

1 2 3 5 7 8 9 4 6 0

Sample Input 2:

10

3 1 2 8 7 5 9 4 6 0

6 4 5 1 0 3 2 7 8 9

Sample Output 2:

Heap Sort

5 4 3 1 0 2 6 7 8 9

#include <stdio.h>
#include <stdbool.h>

/* 输出  */
void output(int A[],int N)
{
    for(int i=0;i<N;i++){
        if(i)
            printf(" ");
        printf("%d", A[i]); 
    } 
} 

bool judge(int A[],int B[],int N)
{
    for(int i=0;i<N;i++)
        if(A[i]!=B[i])
            return false;
    return true;
}

/* 插入排序  */
bool Insertion_Sort(int A[],int B[],int N)
{
    for(int P=1;P<N;P++)
    {
        int tmp = A[P];
        int j = P;
        for(;j>0 && tmp < A[j-1];j--)
            A[j] = A[j-1];
        A[j] = tmp;
        if(judge(A,B,N))
        {   /* 如果相等了，再做一轮  */
            P++;
            int tmp = A[P];
            int j = P;
            for(;j>0 && tmp < A[j-1];j--)
                A[j] = A[j-1];
            A[j] = tmp;
            return true;
        }
    }
    return false; 
}

typedef int ElementType;
void Swap( ElementType *a, ElementType *b )
{
     ElementType t = *a; *a = *b; *b = t;
}
  
void PercDown( ElementType A[], int p, int N )
{ /* 改编代码4.24的PercDown( MaxHeap H, int p )    */
  /* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;
 
    X = A[p]; /* 取出根结点存放的值 */
    for( Parent=p; (Parent*2+1)<N; Parent=Child ) {
        Child = Parent * 2 + 1;
        if( (Child!=N-1) && (A[Child]<A[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= A[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            A[Parent] = A[Child];
    }
    A[Parent] = X;
}
 
bool HeapSort( ElementType A[], ElementType B[], int N ) 
{ /* 堆排序 */
     int i;
       
     for ( i=N/2-1; i>=0; i-- )/* 建立最大堆 */
         PercDown( A, i, N );
      
     for ( i=N-1; i>0; i-- ) {
         /* 删除最大堆顶 */
         Swap( &A[0], &A[i] ); 
         PercDown( A, 0, i );
         if(judge(A,B,N)){
             Swap( &A[0], &A[--i] ); 
             PercDown( A, 0, i );        
             return true;
         }
     }
     return false;
}

int main()
{
    int N;
    scanf("%d", &N);
    int A[N],tmpA[N];
    for(int i=0;i<N;i++){
        scanf("%d", &A[i]);
        tmpA[i] = A[i];
    }
    int B[N];
    for(int i=0;i<N;i++)
        scanf("%d", &B[i]);
    /* 用 A 数组做堆排序，判断是否是归并排序 */ 
    if(HeapSort(tmpA,B,N)){
        printf("Heap Sort
");
        output(tmpA,N);
    }
    /* 用 A 数组做插入排序，判断是否是插入排序 */
    else if(Insertion_Sort(A,B,N)){
        printf("Insertion Sort
");
        output(A,N);
    }
    return 0;
}

10-排序4 统计工龄

给定公司N名员工的工龄，要求按工龄增序输出每个工龄段有多少员工。

输入格式:

输入首先给出正整数N（≤10⁵），即员工总人数；随后给出N个整数，即每个员工的工龄，范围在[0, 50]。

输出格式:

按工龄的递增顺序输出每个工龄的员工个数，格式为：“工龄:人数”。每项占一行。如果人数为0则不输出该项。

输入样例:

8

10 2 0 5 7 2 5 2

输出样例:

0:1

2:3

5:2

7:1

10:1

#include <stdio.h>
#define N 100001

void bucket_sort(int A[],int n){
    int count[55] = {0};
    for(int i=0;i<n;i++)
        count[A[i]]++;
    for(int i=0;i<55;i++)
        if(count[i])
            printf("%d:%d
",i,count[i]);
}

int main()
{
    int A[N];
    int n;
    scanf("%d", &n);
    for(int i=0;i<n;i++)
        scanf("%d", &A[i]);
    bucket_sort(A,n);
    return 0;
}

10-排序5 PAT Judge

The ranklist of PAT is generated from the status list, which shows the scores of the submissions. This time you are supposed to generate the ranklist for PAT.

Input Specification:

Each input file contains one test case. For each case, the first line contains 3 positive integers, N (≤10⁴), the total number of users, K (≤5), the total number of problems, and M (≤10⁵), the total number of submissions. It is then assumed that the user id's are 5-digit numbers from 00001 to N, and the problem id's are from 1 to K. The next line contains K positive integers p[i] (i=1, ..., K), where p[i] corresponds to the full mark of the i-th problem. Then M lines follow, each gives the information of a submission in the following format:

user_id problem_id partial_score_obtained

where partial_score_obtained is either −1 if the submission cannot even pass the compiler, or is an integer in the range [0, p[problem_id]]. All the numbers in a line are separated by a space.

Output Specification:

For each test case, you are supposed to output the ranklist in the following format:

rank user_id total_score s[1] ... s[K]

where rank is calculated according to the total_score, and all the users with the same total_score obtain the same rank; and s[i] is the partial score obtained for the i-th problem. If a user has never submitted a solution for a problem, then "-" must be printed at the corresponding position. If a user has submitted several solutions to solve one problem, then the highest score will be counted.

The ranklist must be printed in non-decreasing order of the ranks. For those who have the same rank, users must be sorted in nonincreasing order according to the number of perfectly solved problems. And if there is still a tie, then they must be printed in increasing order of their id's. For those who has never submitted any solution that can pass the compiler, or has never submitted any solution, they must NOT be shown on the ranklist. It is guaranteed that at least one user can be shown on the ranklist.

Sample Input:

7 4 20

20 25 25 30

00002 2 12

00007 4 17

00005 1 19

00007 2 25

00005 1 20

00002 2 2

00005 1 15

00001 1 18

00004 3 25

00002 2 25

00005 3 22

00006 4 -1

00001 2 18

00002 1 20

00004 1 15

00002 4 18

00001 3 4

00001 4 2

00005 2 -1

00004 2 0

Sample Output:

1 00002 63 20 25 - 18

2 00005 42 20 0 22 -

2 00007 42 - 25 - 17

2 00001 42 18 18 4 2

5 00004 40 15 0 25

下一题预留空格