欢迎使用CSDN-markdown编辑器

#include<iostream>#include<stdio.h>#include<stdlib.h>#define N 10using namespace std;int Partition(int a[],int  low,int  high)           //1快速排序{//返回基准元素的位置    int pivotpos=a[low];//取数组中的第0个元素作为基准元素    while(low<high){//检查整个序列并进行划分，进行一趟排序        while(low<high && a[high]>=pivotpos) --high;        a[low]=a[high];//小于基准元素的放到左边,从右向左查找        while(low<high && a[low]<=pivotpos) ++low;        a[high]=a[low];//大于基准元素的放到右边,从左向右查找    }    a[low]=pivotpos;//将基准元素就位    return low;//返回基准元素的位置}int quicksort(int a[],int const low,int const high){    int i;    int pivotpos;//基准元素的位置    //把参加排序的元素分为两部分，排在左边的元素排序码均比它小    //排在右边的元素排序码均大于或等于它    if(low<high){        //递归调用        pivotpos=Partition(a,low,high);        quicksort(a,low,pivotpos-1);//对左侧子序列实行同样的处理        for(i=0;i<N;++i)printf("%d ",a[i]);        printf("\n");        quicksort(a,pivotpos+1,high);//对右侧子序列实行同样的 处理    }               //元素序列长度≤1时不作处理    return 0;}void Quicksort(int a[],int n)//快排的调用接口函数{    quicksort(a,0,n);}void insert_sort(int *a,unsigned int n)         //2插入排序{    int i,j,k;    int temp;//当前元素    for(i = 1;i < n;i++)    {        temp = *(a + i);        for(j = i;j > 0 && *(a + j - 1) > temp;j--)//比temp大的元素均往后挪一个位置        {            *(a + j) = *(a + j - 1);        }        *(a + j) = temp;//在空出来的那一个位置将temp插入，构成有序子序列        for(k=0;k<N;k++)//每一趟打印排序的结果            printf("%d ",a[k]);        printf("\n");    }}void select_sort(int a[N])          //3选择排序{    int i,j,k,tmp,b;    for(i=0;i<N-1;i++)//一共要查找最小关键码n-1趟    {        tmp=i;//用起始查找元素的下标赋值给tmp        for(j=i+1;j<N;j++)         {           if(a[tmp]>a[j])           tmp=j;//tmp记录最小元素的下标        }        if(i!=tmp)//如果最小元素不是初始的元素，则最小元素与初始元素交换位置        {            b=a[tmp];            a[tmp]=a[i];            a[i]=b;        }            for(k=0;k<N;k++)                printf("%d ",a[k]);            printf("\n");//打印出每一趟查询的结果    }    for(i=0;i<N;i++)        printf("%d ",a[i]);//将最后的结果输出    printf("\n");}void bubble_sort(int a[N])          //4冒泡排序{    int i,j,k,t;    char b=0;    int n;    for(j=0;j<N;j++)//一共进行N-1趟的冒泡    {        for(i=0;i<N-1-j;i++)//每加一趟，待排元素就会减少一个        {            if(a[i]>a[i+1])//最大的会浮在最上面             {t=a[i];  a[i]=a[i+1];  a[i+1]=t;}            for(k=0;k<N;k++)//打印每一趟的结果                printf("%d ",a[k]);            printf("\n");        }    }    printf("排序完成\n");}void build(int *a,int i,int n)//5堆排序{//建立一个最大堆    int k,j,tmp;    k=i;    j=2*k+1;    while(j<=n){        if(j<n && a[j]<a[j+1])            j++;        if(a[k]>=a[j])break;//如果对应子树的根结点的值比左子树的值还大，不用调整        /**只比较了根结点与左子树没有考虑到右子树？？？**/        tmp=a[k];//否则，将大的元素上滑siftup        a[k]=a[j];        a[j]=tmp;        k=j;//在子树中继续查找        j=2*j+1;    }}/* 显示数组函数 */void Print(int *a,int n){    int i;    printf("\n");    for(i=0;i<n;i++){        printf("%3d",a[i]);    }    printf("\n");}/* 显示堆函数 */ void prnthp(int *a,int b1,int b2) {     int size;     int h=0,sum=0,item=1;     int i,j,cnt,start,tmp;     size=b2-b1+1;     while(sum<=size){         sum+=item;         h++;          item*=2;     }     item=1;     cnt=0;     start=b1;     tmp=1;     printf("\n--------------------------------------------\n");     printf("  堆：\n");     while(1){         for(i=0;i<h;i++){                 for(j=0;j<h-i;j++)                                 printf("    ");                  for(j=0;j<i+1;j++)printf(" ");                 for(j=0;j<tmp;j++){                                 if(cnt>size-1)goto end;                                 printf("%4d",a[cnt++]);                 }                 printf("\n");                 tmp*=2;         }      }      end:           printf("\n");           return;  }void prntar(int *a,int b2,int len){//输出当前已经排好序的元素  int i;  printf("  已排序：\n");  for(i=0;i<b2;i++){//b2为仍未排序的元素的个数a[0]~a[b2-1]仍未排序    printf("   ");  }  for(i=b2;i<=len;i++){//a[b2]~a[n-1]已经排好序    printf("%3d",a[i]);  }  printf("\n");}                           //5堆排序/**堆排序暂时放放**/void merge_sort(int *a, int length)                 ///6归并排序{//参数说明：length为数组的长度    int i,j, left_min, left_max;    int right_min, right_max, next;    int *tmp = (int*)malloc(sizeof(int) * length);    if (tmp == NULL)//如果空间申请失败则终止程序    {        fputs("Error: out of memory\n", stderr);        /*        fputs是一种函数，具有的功能是向指定的文件写入一个字符串。        成功写入一个字符串后，文件的位置指针会自动后移，        函数返回为一个非负整数；否则返回EOF（符号常量，其值为-1）。        */        abort();        //函数名: abort 功 能: 异常终止一个进程    }    for (i = 1; i < length; i *= 2)    {        for (left_min = 0; left_min < length - i; left_min = right_max)        {            right_min = left_max = left_min + i;            right_max = left_max + i;            if (right_max > length)                right_max = length;                next = 0;            while (left_min < left_max && right_min < right_max)                tmp[next++] = a[left_min] > a[right_min] ? a[right_min++] : a[left_min++];            while (left_min < left_max)                a[--right_min] = a[--left_max];            while (next > 0)                a[--right_min] = tmp[--next];            for(int j=0;j<10;j++)                printf("%d ",a[j]);            printf("\n");        }    }    free(tmp);//释放tmp申请的空间}                           //6归并排序int RadixCountSort(int* npIndex, int nMax, int* npData, int nLen)           //7基数排序{    int* pnCount  = (int*)malloc(sizeof(int)* nMax);        //保存计数的个数    int i=0,j;    for (i = 0; i < nMax; ++i)    {        pnCount[i] = 0;    }    for (i = 0; i < nLen; ++i)    //初始化计数个数    {        ++pnCount[npIndex[i]];    }    for (i = 1; i < 10; ++i)  //确定不大于该位置的个数。    {        pnCount[i] += pnCount[i - 1];    }    int * pnSort  = (int*)malloc(sizeof(int) * nLen);    //存放零时的排序结果。    //注意：这里i是从nLen-1到0的顺序排序的，是为了使排序稳定。    for (i = nLen - 1; i >= 0; --i)    {        --pnCount[npIndex[i]];        pnSort[pnCount[npIndex[i]]] = npData[i];    }    for (i = 0; i < nLen; ++i)        //把排序结构输入到返回的数据中。    {        npData[i] = pnSort[i];    }    free(pnSort);                        //记得释放资源。    free(pnCount);    return 1;}//基数排序int RadixSort(int* nPData, int nLen){    //申请存放基数的空间    int* nDataRadix    = (int*)malloc(sizeof(int) * nLen);    int nRadixBase = 1;    //初始化倍数基数为1    int nIsOk = 0; //设置完成排序为false    int i,j;    //循环，直到排序完成    while (nIsOk==0)    {        nIsOk = 1;        nRadixBase *= 10;        for (i = 0; i < nLen; ++i)        {            nDataRadix[i] = nPData[i] % nRadixBase;            nDataRadix[i] /= nRadixBase / 10;            if (nDataRadix[i] > 0)            {                nIsOk = 0;            }        }        if (nIsOk==1)        //如果所有的基数都为0，认为排序完成，就是已经判断到最高位了。        {            break;        }        RadixCountSort(nDataRadix, 10, nPData, nLen);    }    free(nDataRadix);    return 1;}int main(){    int choice=0;    int a[10]={91,8,73,82,56,49,35,27,14,0};    printf("************************排序演示************************\n");    printf("本演示程序对数字序列91,8,73,82,56,49,35,27,14,0进行排序演示\n\n");    printf("选择排序方式：\n");    printf("1.快速排序\n2.插入排序\n3.选择排序\n4.冒泡排序\n5.堆排序\n6.归并排序\n7.基数排序\n");    while(1){    scanf("%d", &choice);    if(choice==0)break;    if(choice==1)    {        int i;        Quicksort(a,9);        for(i=0;i<10;printf("%d ",a[i]),++i);        printf("\n排序完成\n");//快速    }    else if(choice==2)    {        int i;        insert_sort(a,10);        for(i=0;i<10;i++)            printf("%d ",a[i]);        printf("\n排序完成\n");//插入    }    else if(choice==3)    {        select_sort(a);        printf("排序完成\n");//选择    }    else if(choice==4)    {        printf("\n\n");        bubble_sort(a);//冒泡    }    else if(choice==5)    {        int i;        int tmp;        int sum;        int num;        int len;        printf("\n============================================\n");        len=N;//存储对元素的数组长度        tmp=1;        sum=0;        while(sum+tmp<=len){            sum+=tmp;            tmp*=2;        }        printf("\n============================================\n");        /* 建初始堆 */        for(i=sum-1;i>=0;i--)            build(a,i,len-1);         prnthp(a,0,len-1);        /* 改建堆 */        for(i=0;i<len-1;i++){            tmp=a[0];            a[0]=a[len-1-i];            a[len-1-i]=tmp;            build(a,0,len-2-i);             prnthp(a,0,len-2-i);            prntar(a,len-1-i,len-1);        }        printf("\n--------------------------------------------\n");        printf("\n  排序结果：\n");        Print(a,len);        printf("\n============================================\n排序完成\n");//堆        }    else if(choice==6)    {        merge_sort(a,10);        for(int j=0;j<10;j++)            printf("%d  ",a[j]);        printf("\n排序完成\n");//归并    }    else if(choice==7)    {        int i=0;        int j;        RadixSort(a, 10);        for (i = 0; i < 10; ++i)            printf("%d ", a[i]);        printf("\n排序完成\n");//基数    }    else        printf("输入有误\n");    cout<<"请继续输入排序方法代表的编号，如停止排序请输入0"<<endl;    printf("1.快速排序\n2.插入排序\n3.选择排序\n4.冒泡排序\n5.堆排序\n6.归并排序\n7.基数排序\n");    }    return 0;}

CRITICAL_PATH

#include<iostream>#include<fstream>#include<stdio.h>#include <stdlib.h>#define MaxVerNum 20//结点的最大数量using namespace std;int visited[MaxVerNum];//访问标志typedef char VertexType;//定义顶点类型struct Edge;typedef struct Vertex//定义边结点的结构体类型{       VertexType data;//存放结点的信息       int indegree;//出度用于标记该顶点的出度       Edge *firstlink;//下一条边的链指针}Vertex, Adjlist[MaxVerNum];//定义一个结构体数组，用于存储结点的信息typedef struct Edge//定义顶点的结构体类型{       int adjvex;//该弧指向的顶点位置(邻接顶点)       struct Edge *link; //指向下一个边结点       int cost; //两个结点之间的权值信息}Edge;//边结点类型typedef struct{       Adjlist vertices; //邻接表 Adjlist为指针类型       int vernum, arcnum; //顶点数和弧数}ALGraph;//生成一个实体邻接表//查找符合的数据在数组中的下标int LocateVer(ALGraph G, char u){       int i;       for(i = 0; i < G.vernum; i++)       {              if(u == G.vertices[i].data)                     return i;//如果找到对应结点                            //返回所要查找的结点的下标       }       if(i == G.vernum)       {              cout<<"Error u!\n";//如果循环一遍都没找到则报错退出程序              exit(1);       }       return 0;}//常见图的邻接矩阵void CreateALGraph(ALGraph &G)///若不采用引用类型，会生成一个副本                              ///变量会 数组不会 【结构体会吗（？）】{       int i, j, k, w;       char v1, v2;       Edge * p;       cout<<"输入顶点数和弧数: ";       cin>>G.vernum>>G.arcnum;       cout<<"请输入顶点!\n";       for(i = 0; i < G.vernum; i++)//先建立一个不带边结点的邻接表       {              cout<<"请输入第 "<<i<<"个顶点: \n";//              fflush(stdin);//清除缓冲区              cin>>G.vertices[i].data;//输入顶点的数据信息              G.vertices[i].firstlink= NULL;//边指针为空              G.vertices[i].indegree = 0;//顶点出度为0       }       for(k = 0; k < G.arcnum; k++)//给各个结点之间连接的边赋权值       {              cout<<"请输入弧的顶点和相应权值(v1, v2, w): \n";              //清空输入缓冲区              fflush(stdin);              cin>>v1>>v2>>w;              i = LocateVer(G, v1);              j = LocateVer(G, v2);              p=new Edge;//建立一个边结点              p->adjvex = j;//边结点的邻接顶点指针指向所连接的下一个顶点              p->cost = w;//给两个结点之间的边赋权值              p->link = G.vertices[i].firstlink;//利用头插法插入边结点              G.vertices[i].firstlink = p;//（最后一个边结点的link指向该层的起始顶点的初始指针NULL）              G.vertices[j].indegree++;//vi->vj, vj入度加1（用于计算该顶点的出度）       }       return;}///求图的关键路径函数（KEY_POINT）void CriticalPath(ALGraph G){       int i, k;       int Ae, Al;//各个活动开始的最早时间和最晚时间       int * Ve, * Vl;//顶点事件的最早发生时间以及最晚发生时间       Edge * p;//指向边结点的指针       //*****************************************       //以下是求时间最早发生时间       //*****************************************///拓扑(求到达每一个顶点的最长路径)       Ve = new int [G.vernum];//定义一个数组存储各个结点最早发生时间       Vl = new int [G.vernum];//定义一个数组存储各个结点最晚发生时间       for(i = 0; i < G.vernum; i++) //前推              Ve[i] = 0;//将数组中的各个元素初始化为0       for(i = 0; i < G.vernum; i++)       {//对每一个顶点的每一个边结点都遍历查找一遍        //记录能访问到的最长路径              Edge * p = G.vertices[i].firstlink;              while(p != NULL)//若没有到该层的末尾              {                     k = p->adjvex;                     if( (Ve[i] + p->cost) > Ve[k])//如果当前查找到的路径比原来更长                            Ve[k] = Ve[i]+p->cost;                     p = p->link;//继续查找              }       }///逆拓扑(在一趟正向拓扑的前提下，逆序求从汇点到达各个顶点的相对最短路径)       //*****************************************       //以下是求最迟发生时间       //*****************************************       for(i = 0; i < G.vernum; i++)              Vl[i] = Ve[G.vernum-1];       //将Ve中的最大值作为初始值付给Vl[]中的每一个元素       for(i = G.vernum-2; i >= 0; i--)                 //后推       {//从倒数第二个记录向前查找              p = G.vertices[i].firstlink;              while(p != NULL)              {                     k = p->adjvex;                     if( (Vl[k] - p->cost )< Vl[i] )//如果当前查找到的路径比原来更短                                                    //则将所得到的较小的值付给vl[i]                            Vl[i] = Vl[k] - p->cost;                     p = p->link;//继续向后查找              }       }       //******************************************       for(i = 0; i < G.vernum; i++)//打印求解后的结果       {              p = G.vertices[i].firstlink;              while(p != NULL)              {                     k = p->adjvex;                     Ae = Ve[i];              //最早开始时间为时间vi的最早发生时间                     Al = Vl[k] - p->cost;           //最迟开始时间        /**此处为什么不能是l = Vl[i]而是要写成l = Vl[k]-p->cost **///                     char tag = (Ae == Al) ? '*' : ' '; //关键活动标记符号//                     printf("<%c, %c>, early = %2d, late = %2d, %c\n", G.vertices[i].data, G.vertices[k].data, Ae, Al, tag);                     if(Ae == Al)printf("<%c,%c> 是关键活动\n",G.vertices[i].data, G.vertices[k].data);                     p = p->link;              }       }       cout<<endl<<"The total length is:"<<Ve[G.vernum-1];       delete [] Ve;//释放申请地空间       delete [] Vl;//释放申请地空间}  main(){       ALGraph G;       cout<<"以下是查找图的关键路径的程序。\n";       CreateALGraph(G);//创建邻接表       ALGraph B=G;       CriticalPath(B);//查找关键路径并输出最终的查找结果}/**test data9 110 1 2 3 4 5 6 7 80 1 60 2 40 3 51 4 12 4 13 5 24 6 94 7 75 7 46 8 27 8 4**/

https://wenku.baidu.com/view/6b611332ddccda38376baf91.html?from=search
https://wenku.baidu.com/view/c579bd2f48d7c1c708a14563.html?from=search
https://wenku.baidu.com/view/f2671ae48e9951e79b8927a3.html?from=search
https://wenku.baidu.com/view/c579bd2f48d7c1c708a14563.html?from=search
https://wenku.baidu.com/search?word=ACM+%BB%F9%B4%A1%CB%E3%B7%A8&org=0
https://wenku.baidu.com/view/2308916d2af90242a895e542.html?from=search

include

define N 60

int s,map[N+1][N+1];
typedef struct{

int x,y;
}xy;
xy queue[N*N],start,end,last;
void depth(int x,int y)
{
if(map[x][y]==1)
{
s++;
x=last.x;
y=last.y;
return ;
}
last.x=x;
last.y=y;
if(x==1&&y==1)
return ;
if(map[x-1][y]==map[x][y]-1)
depth(x-1,y);
if(map[x+1][y]==map[x][y]-1)
depth(x+1,y);
if(map[x][y-1]==map[x][y]-1)
depth(x,y-1);
if(map[x][y+1]==map[x][y]-1)
depth(x,y+1);
}
int main()
{
int front=0,rear=0;
int n,m,k,i,j;
scanf(“%d%d%d”,&n,&m,&k);
for(i=0;i<=N;i++)
for(j=0;j<=N;j++)
map[i][j]=0;
while(k–){

    scanf("%d%d",&i,&j);    map[i][j]=-1;}scanf("%d%d",&start.x,&start.y);scanf("%d%d",&end.x,&end.y);queue[front].x=start.x;queue[front].y=start.y;map[start.x][start.y]=1;while(front<rear){    i=queue[front].x;    j=queue[front].y;    if(i==end.x&&j==end.y)        break;    if(i-1>0&&map[i-1][j]==0)    {        map[i-1][j]=map[i][j]+1;        queue[rear].x=i-1;        queue[rear].y=j;        rear++;    }    if(j-1>0&&map[i][j-1]==0)    {        map[i][j-1]=map[i][j]+1;        queue[rear].x=i;        queue[rear].y=j-1;        rear++;    }    if(i+1<=n&&map[i+1][j]==0)    {        map[i+1][j]=map[i][j]+1;        queue[rear].x=i+1;        queue[rear].y=j;        rear++;    }    if(j+1<=m&&map[i][j+1]==0)    {        map[i][j+1]=map[i][j]+1;        queue[rear].x=i;        queue[rear].y=j+1;        rear++;    }    front++;    if(front==rear)        printf("No Solution!\n");    else{        s=0;        last.x=i;        last.y=j;        printf("%d\n",map[i][j]-1);        depth(i,j);        printf("%d\n",s);    }    return 0;}

}