代码随记-算法设计与分析课程设计

主要是记录代码，没有排版美化

---

分治法-循环赛制问题

题目：
2019年，德国甲级联赛刚刚落下帷幕。设有n支队伍参加循环赛，要求设计一个满足以下要求比赛日程表：
1）每支队伍必须与其它n-1支队伍各赛一次；
2）每支队伍一天只能赛一次。

非递归

代码

#include<bits/stdc++.h>
using namespace std;

int a[100][100];
//从（fromx,fromy）复制到（tox,toy）规模为r的正方形
void Copy(int tox, int toy, int fromx, int fromy, int r){
    for (int i=0; i<r; i++){
        for (int j =0; j<r; j++){
           a[tox+i][toy+j] = a[fromx+i][fromy+j];
        }
    }
}

void Table(int n){
    for (int r=1; r<n; r*=2){ //控制规模的大小,次方
        for(int j=0;j<n;j+=r*2){//控制列的下标
            Copy(r,r+j,0,j,r);//从左上拷贝到右下
            Copy(r,j,0,r+j,r);//从右上拷贝到左下
        }
    }
}

void Print(int n){
    cout<<"循环赛日程为:"<<endl;
    for(int i =0;i<n;i++){
        for(int j=0; j<n; j++){
            printf("%4d",a[i][j]);
        }
        cout<<endl;
    }
}

int main(){
    //初始化
    int n;
    cout<<"请输入k值(2的k次方只队伍)"<<endl;
    int k;
    cin>>k;
    n=pow(2,k);
    for(int i=0;i<n;i++){
        a[0][i] = i+1; //初始化第一行 填充数据，把第一行填满
    }
    Table(n);
    Print(n);
return 0;
}

输入与输出

动态规划-台阶问题

题目
有n级台阶，一个人每次上一级或者两级，问有多少种走完n级台阶的方法。
实际情况：给定一个矩阵m，从左上角开始每次只能向右走或者向下走，最后达到右下角的位置，路径中所有数字累加起来就是路径和，返回所有路径的最小路径和，如果给定的m如下，那么路径1,3,1,0,6,1,0就是最小路径和，返回12.
1 3 5 9
8 1 3 4
5 0 6 1
8 8 4 0
代码

#include <bits/stdc++.h>
using namespace std;

const int N=1e3+10;

int n,m,dp[N][N],a[N][N];

char rec[N][N];

void printRoad(char rec[N][N],int i,int j)
{
    if(i==0||j==0) return;
    if(rec[i][j]=='L')
    {
        printf("(%d,%d)\n",i,j);
        printRoad(rec,i,j-1);
    }
    else
    {
        printf("(%d,%d)\n",i,j);
        printRoad(rec,i-1,j);
    }
}


int main()//对比最长公共子序列问题
{
    ios::sync_with_stdio(false);//
    cin>>n>>m;
    for(int i=1; i<=n; i++)
    {
        for(int j=1; j<=m; j++)
        {
            cin>>a[i][j];
            if(i==1) // 第一行只能由左边走到
            {
                dp[i][j]=dp[i][j-1]+a[i][j];
                rec[i][j]='L';
                path[i][j]= {i,j-1};
            }
            else if(j==1){
            dp[i][j]=dp[i-1][j]+a[i][j];
            path[i][j]= {i-1,j};
            rec[i][j]='U';
            }
            else
            {
                if(dp[i-1][j]<=dp[i][j-1])//比较左边和上面
                {
                    dp[i][j]=dp[i-1][j]+a[i][j];//上边小
                    rec[i][j]='U';//记录路径，便于回溯
                }
                else
                {
                    dp[i][j]=dp[i][j-1]+a[i][j];
                    rec[i][j]='L';
                }
            }
        }
    }
    printf("最短距离：%d\n",dp[n][m]);
    printf("\n最短路径：\n");
    printRoad(rec,0,0);
    return 0;
}
/*
4 4
1 3 5 9
8 1 3 4
5 0 6 1
8 8 4 0

1 4 9 18
9 5 8 12
14 5 11 12
22 13 15 12
ans:
最短距离：12

最短路径：
(1,1)
(1,2)
(2,2)
(3,2)
(3,3)
(3,4)
(4,4)

4 4
1 3 1 9
3 1 3 4
5 0 6 1
8 8 4 0
ans：
最短距离：12

最短路径：
(1,1)
(1,2)
(2,2)
(3,2)
(3,3)
(3,4)
(4,4)
*/

贪心问题-火车站台安排问题

题目：
站台安排问题：一个火车站有一个所有火车到达和离开的时间表，需要找出最小站台数，使得按照此时间表调度时，可以容纳所有的火车。已知火车时刻表如下所示，试编程实现，需要的最少站台有几个。

代码

#include <bits/stdc++.h>

using namespace std;
const int N=1e3+10;

int A[N],ans=0,k,flag=0;

struct node
{
    int s,f,num,p;
} train[N];

bool cmp(node a1,node a2)
{
    return a1.f<a2.f;
}

int Selector(int n)
{
    int j;
    for(int i=1;i<=n;i++)//
    if(train[i].p){
        A[i]=1;
        j=i;
        break;
    }
    for(int i=j+1; i<=n; i++)
    {
        if(train[i].p)
        {
            if(train[i].s>=train[j].f){
                A[i]=1;
                j=i;
            }
            else
                A[i]=0;
        }
        if(k==1&&train[i].p==1)
        {
            A[i]=1;
            train[i].p=1;
            return ++ans;
        }
    }
    return ++ans;
}


int main()
{
    int n,cnt=0;//火车数目
    cout<<"请输入火车数目：";
    scanf("%d",&n);
    cout<<endl<<"请依次输入火车序号，到站时间，离站时间："<<endl;
    for(int i=1; i<=n; i++)
    {
        cin>>train[i].num>>train[i].s>>train[i].f; //录入火车数据
        train[i].p=1;
    }
    cout<<endl<<"按最早离开时间排序后："<<endl;
    sort(train+1,train+n+1,cmp);
    for(int i=1; i<=n; i++){
        printf("%d %.4d %.4d\n",train[i].num,train[i].s,train[i].f);
    }
    cout<<endl;
    while(true){
        ans=Selector(n);
        printf("第%d站：\n",++cnt);
        for(int i=1; i<=n; i++)
        {
            if(A[i]&&train[i].p){
                train[i].p=0;
                printf("%d %d %d\n",train[i].num,train[i].s,train[i].f);
            }
        }
        int k;
        for(k=1;k<=n;k++)
        if(train[k].p==1) break;
        if(k==n+1) break;
        cout<<endl;
    }
    cout<<endl<<"站台数目：";
    cout<<ans<<endl;
    return 0;
}
/*
4
1 0900 0930
2 0915 1300
3 1030 1100
4 1045 1145
排序后
1 0900 0930
3 1030 1100
4 1045 1145
2 0915 1300

5
1 0900 0930
2 0915 1300
3 1030 1100
4 1045 1145
5 1130 1200
排序后
1 0900 0930
3 1030 1100
4 1045 1145
5 1130 1200
2 0915 1300

4
1 0900 1000
2 0945 1015
3 1030 1100
4 1015 1200
排序后
1 0900 1000
2 0945 1015
3 1030 1100
4 1015 1200

4
1 0900 0930
2 0920 0950
3 1000 1200
4 0940 1500
*/

回溯法-素数环问题

题目
问题描述：输入正整数n，把整数1,2,3,4……n组成一个环，使得相邻的两个整数之和均为素数。
样例
输入：
6
输出：1 4 3 2 5 6
1 6 5 2 3 4

代码

#include <bits/stdc++.h>
using namespace std;

int a[100],t[100],n;//a是满足数组，t是记录数组

void print()      //输出
{
    if(a[1]==1)
    {
        for(int k=1; k<=n; ++k)
            cout<<a[k]<<" ";
    }
    cout<<endl;
}

int isPrime(int x)    //判断素数
{
    if(x==0||x==1)
        return 0;
    for(int i=2; i<=sqrt(x); ++i)
        if(x%i==0)
            return 0;
    return 1;
}

void DFS(int x)     //搜索回溯
{
    for(int i=2; i<=n; i++)
        if(isPrime(i+a[x-1])&&(!t[i])) //如果相邻是质数,且没有被使用过,记录.
        {
            a[x]=i;
            t[i]=1;
            if(x==n){//如果加满了
                if(isPrime(a[n]+a[1]))//判断首尾
                    print();
            }
            else//没有加满，就回溯
                DFS(x+1);//回溯

            t[i]=0;//清零，为下一次准备
        }
}

int main()
{
    scanf("%d",&n);
    a[1]=1;
    DFS(2);
    return 0;
}