PTA题目测试

函数

6-1 二分查找

Position BinarySearch(List L, ElementType X)
{
    int left = 0, right = L->Last;
    int mid = (left + right) / 2;
    while (left <= right)
    {
        mid = (left + right) / 2;
        if (L->Data[mid] == X)
            return mid;
        else if (L->Data[mid] < X)
            left = mid + 1;
        else
            right = mid - 1;
    }
    return NotFound;
}

6-4 单链表逆转

List Reverse(List L)
{
    List p, q;
    p = L;
    L = NULL;
    while (p)
    {
        q = p;
        p = p->Next;
        q->Next = L;
        L = q;
    }
    return L;
}

6-7 另类循环队列

bool AddQ(Queue Q, ElementType X)
{
    if (Q->Count == Q->MaxSize)
    {
        printf("Queue Full\n");
        return false;
    }
    Q->Count++;
    Q->Data[(Q->Front + Q->Count) % Q->MaxSize] = X;
    return true;
}

ElementType DeleteQ(Queue Q)
{
    if (Q->Count == 0)
    {
        printf("Queue Empty\n");
        return ERROR;
    }
    Q->Count--;
    Q->Front = (Q->Front + 1) % Q->MaxSize;
    return Q->Data[Q->Front];
}

6-8 双端队列

bool Push(ElementType X, Deque D)
{
    if ((D->Rear+ 1) % D->MaxSize == D->Front)
        return false;
    D->Front = (D->Front - 1 + D->MaxSize) % D->MaxSize;
    D->Data[D->Front] = X;
    return true;
}
ElementType Pop(Deque D)
{
    ElementType e;
    if(D->Front == D->Rear)
        return ERROR;

    e = D->Data[D->Front];
    D->Front = (D->Front + 1) % D->MaxSize;
    return e;

}
bool Inject(ElementType X, Deque D)
{
    if ((D->Rear + 1) % D->MaxSize == D->Front)
        return false;
    D->Data[D->Rear] = X;
    D->Rear = (D->Rear + 1) % D->MaxSize;
    return true;
}
ElementType Eject(Deque D)
{
    if (D->Front == D->Rear)
    {
        return ERROR;
    }
    D->Rear = (D->Rear - 1 + D->MaxSize) % D->MaxSize;
    return D->Data[D->Rear];
}

6-9 求二叉树高度

int GetHeight(BinTree BT)
{
    int hleft, hright, max;
    if (BT  == NULL)
        return 0;
    hleft = GetHeight(BT->Left);
    hright = GetHeight(BT->Right);
    max = hleft > hright ? hleft : hright;
    return max + 1;
}

6-10 邻接矩阵存储图的深度优先遍历

void DFS(MGraph Graph, Vertex V, void (*Visit)(Vertex))
{
    Visited[V] = true;
    Visit(V);
    for (int i = 0; i < Graph->Nv; i++)
    {
        if (Graph->G[V][i] == 1 && !Visited[i])
            DFS(Graph, i, Visit);
    }
    return true;
}

6-11 邻接表存储图的广度优先遍历

void BFS(LGraph Graph, Vertex S, void (*Visit)(Vertex))
{
    Visit(S);
    Visited[S] = true;
    Vertex que[105];
    int front = 0, rear = 0;
    que[rear++] = S;
    PtrToAdjVNode p;
    while (front < rear)
    {
        Vertex x = que[front];
        front++;
        p = Graph->G[x].FirstEdge;
        while (p)
        {
            Vertex v = p->AdjV;
            if (!Visited[v])
            {
                Visit(v);
                Visited[v] = true;
                que[rear++] = v;
            }
            p = p->Next;
        }
        }
}

6-4（选做） 线性探测法的查找函数

Position Find(HashTable H, ElementType Key)
{
    Position p0, p;
    int Cnum = 0; // 冲突数
    p0 = Hash(Key, H->TableSize);
    p = p0;
    
    while (H->Cells[p].Info != Empty && H->Cells[p].Data != Key)
    {
        Cnum++;
        if (Cnum == MAXTABLESIZE)
        {
            return ERROR; // 返回错误码，表示未找到或冲突过多
        }
        p = (p0 + Cnum) % H->TableSize;
    }
    
    return p;
}

6-13 Iterative Mergesort

void merge_pass(ElementType list[], ElementType sorted[], int N, int length)
{
    int i, num1, num2, last, num;
    for (i = 0; i < N; i = i + 2 * length)
    {
        num1 = i;
        num2 = i + length;
        num = i;
        if (i + 2 * length > N)
            last = N;
        else
            last = i + 2 * length;

        while (num1 < i + length && num2 < last && num1 < N && num2 < N)
        {
            if (list[num1] < list[num2])
                sorted[num++] = list[num1++];
            else
                sorted[num++] = list[num2++];
        }
        while (num1 < i + length)
        {
            sorted[num++] = list[num1++];
        }
        while (num2 < last)
        {
            sorted[num++] = list[num2++];
        }
    }
}

6-14 Quick Power

int Power(int N, int k)
{
    int n = 1;
    N = N % MOD;
    while (k)
    {
        if (k % 2 == 1)
            n = n * N % MOD;
        k /= 2;
        N = N * N % MOD;
    }
    return n;
}

6-15 划分整数数组

int Partition(int a[],int n)
{
    int pivotkey, low = 0, low0 = 0, high = n - 1, high0 = n - 1, flag = 1, k = n / 2, i;
    int s1 = 0, s2 = 0;
    while (flag)
    {
        pivotkey = a[low];
        while (low < high)
        {
            while (low < high && a[high] >= pivotkey)
                --high;
            if (low != high)
                a[low] = a[high];
            while (low < high && a[low] <= pivotkey)
                ++low;
            if (low != high)
                a[high] = a[low];
        }
        a[low] = pivotkey;
        if (low == k - 1)
            flag = 0;
        else if (low < k - 1)
        {
            low0 = ++low;
            high = high0;
        }
        else
        {
            high0 = --high;
            low = low0;
        }
    }
    for (i = 0; i < k; i++)
        s1 += a[i];
    for (i = k; i < n; i++)
        s2 += a[i];
    return s2 - s1;
}

贪心

7-1 堆栈操作合法性

## include <iostream>
## include <string>
using namespace std;

int n, m;

void Solve()
{
    char c;
    int flag = 1,i, length = 0;
    string s;
    cin >> s;
    for (i = 0; i < s.length(); i++)
    {
        if (s[i] == 'S')
        {
            length++;
            if (length > m)
                flag = 0;
        }
        if (s[i] == 'X')
        {
            length--;
            if (length < 0)
                flag = 0;
        }
    }
    if (flag == 1 && length == 0)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
int main()
{
    cin >> n >> m;
    while (n--)
    {
        Solve();
    }
}

7-2 银行业务队列简单模拟

## include <iostream>
## include <vector>
using namespace std;

int main()
{
    int i, j = 0, k = 0;
    int n, x;
    cin >> n;
    int a[n], b[n], ans[n];
    for (i = 0; i < n; i++)
    {
        cin >> x;
        if (x % 2 == 1)
            a[j++] = x;
        else
            b[k++] = x;
    }
    int index = 0, indexj = 0, indexk = 0;
    while (indexj < j || indexk < k)
    {
        if (indexj < j)
            ans[index++] = a[indexj];
        if (indexj + 1 < j)
            ans[index++] = a[indexj + 1];
        indexj += 2;

        if (indexk < k)
            ans[index++] = b[indexk];
        indexk++;
    }
    for (i = 0; i < index - 1; i++)
        cout << ans[i] << " ";
    cout << ans[index - 1] << endl;

    return 0;
}

7-3 PAT排名汇总

7-4 根据后序和中序遍历输出先序遍历

## include <iostream>
using namespace std;

void Pre(int mid[], int post[], int n)
{
    if (n <= 0)
        return;
    int root = post[n - 1], i;
    for (i = 0; i < n; i++)
    {
        if (mid[i] == root)
            break;
    }
    cout << " " << root;
    Pre(mid, post, i);
    Pre(mid + i + 1, post + i, n - i - 1);
}
int main()
{
    int i, n;
    int post[31], mid[31];

    cin >> n;
    for (i = 0; i <  n; i++)
        cin >> post[i];
    for (i = 0; i < n; i++)
        cin >> mid[i];
    cout << "Preorder:";
    Pre(mid, post, n);
}

7-4（选做） 公路村村通

## include <iostream>
## include <algorithm>
using namespace std;
const int N = 10010;
struct ss
{
    int fron, to, price;
} ro[N];
int pre[N], n, m;
int find(int x)
{
    if (x == pre[x])
        return x;
    return find(pre[x]);
}
bool cmp(ss a, ss b)
{
    return a.price < b.price;
}
int main()
{
    int i, xx, yy;
    cin >> n >> m;
    for (i = 1; i <= n; i++)
        pre[i] = i;
    for (i = 1; i <= m; i++)
        cin >> ro[i].fron >> ro[i].to >> ro[i].price;
    sort(ro + 1, ro + 1 + m, cmp);
    int sum = 0;
    for (i = 1; i <= m; i++)
    {
        xx = find(ro[i].fron);
        yy = find(ro[i].to);
        if (xx != yy)
        {
            pre[yy] = xx;
            sum += ro[i].price;
        }
    }
    int cnt = 0;
    for (i = 1; i <= n; i++)
    {
        if (find(pre[i]) == i)
            cnt++;
    }
    if (cnt > 1)
        cout << -1 << endl;
    else
        cout << sum << endl;
    return 0;
}

7-5 冒泡法排序

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

int main()
{
    int i, n, j, K;
    cin >> n >> K;
    int a[n + 1];
    for (i = 0; i < n; i++)
        cin >> a[i];
    while (K--)
    {
        for (i = 0; i < n - 1; i++)
        {
            if (a[i] > a[i + 1])
                swap(a[i], a[i + 1]);
        }
    }
    for (i = 0; i < n - 1; i++)
        cout << a[i] << " ";
    cout << a[n - 1];
}

7-7（选做） 旅游规划

## include <bits/stdc++.h>
using namespace std;
## define INF 1e9
const int n = 1e4 + 10;
struct ss{
    int len, val;
};
int dis[n], mon[n], vis[n], N, M, S, D;
struct ss g[n][n];
void nanie()
{
    int i, c, j;
    for(i = 0; i < N ; i++)
    {
        dis[i] = g[S][i].len;
         if(g[S][i].len != INF)
         {
             dis[i] = g[S][i].len;
             mon[i] = g[S][i].val;
         }
    }
    for(i = 0; i <N; i++)
    {
        int tep = INF;
        c = S;
    for(j = 0; j < N; j++)
    {
        if(!vis[j] && tep > dis[j])
        {
            tep = dis[j];
            c = j;
        }
    }
    if(c == S)
        return;
    vis[c] = 1;
    for(j = 0; j < N; j++)
    {
        if(!vis[j] && dis[j] > dis[c] + g[c][j].len)
        {
            dis[j] = dis[c] + g[c][j].len;
            mon[j]  = mon[c] + g[c][j].val;
        }
        else if(!vis[j] && dis[j] == dis[c] + g[c][j].len && dis[j] != INF)
        {
            mon[j] = min(mon[j], mon[c] + g[c][j].val);
        }
    }
    }
}
int main()
{
    int i, u, v, s, vl, j;
    cin >> N >> M >> S >> D;
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < N; j++)
        {
            g[i][j].len = INF;
            g[i][j].val = INF;
        }
    }
    for(i = 0; i < M; i++)
    {
        cin >> u >> v >> s >> vl;
        g[v][u].len = s;
        g[u][v].len = s;
        g[v][u].val = vl;
        g[u][v].val = vl;
    }
    dis[S] = 0;
    mon[S] = 0;
    vis[S] = 1;
    nanie();
    cout << dis[D] << " " << mon[D] <<endl;
    return 0;
}

7-3 城市间紧急救援

最短路径 + 多条路径用dod存 + 救援队数量mon + pre便利最优

## include <iostream>
## include <stack>
## define INF 1e9
using namespace std;
const int n = 1000;
int pre[n], mon[n], dod[n], g[n][n], dis[n], vis[n], num[n];
int N, M, S, D;
void nanie()
{
    int i, j, c;
    for(i = 0; i < N; i++)
    {
        dis[i] = g[S][i];
        if(g[S][i] != INF)
        {
            dod[i] = 1;
            mon[i] = num[S] + num[i];
            pre[i] = S;
            
        }
        else
        {
            pre[i] = -1;
        }
    }
    vis[S] = 1;
    dis[S] = 0;
    for(i = 0; i < N; i++)
    {
        c = S;
        int tep = INF;
        for(j = 0; j < N; j++)
        {
            if(dis[j] < tep && !vis[j])
            {
                tep = dis[j];
                c = j;
            }
        }
        if(c == S)
            return;
        vis[c] = 1;
        for(j = 0; j < N; j++)
        {
            if(dis[j] > dis[c] + g[c][j] &&!vis[j])
            {
                dis[j] = dis[c] + g[c][j];
                dod[j] = dod[c];
                mon[j] = mon[c] + num[j];
                pre[j] = c;
            }
            else if(dis[j] == dis[c] + g[c][j] &&!vis[j])
            {
                dod[j] += dod[c];
                if(mon[j] < mon[c] + num[j])
                {
                    mon[j] = mon[c] + num[j];
                    pre[j] = c;
                }
            }
        }
    }
}
int main()
{
    cin >> N >> M >>S >>D;
    int i, u, v, dd, j;
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < N; j++)
            g[i][j] = INF;
    }
    for(i = 0; i < N;i ++)
        cin >> num[i];
    for(i = 0; i < M; i++)
    {
        cin >>u >>v >> dd;
        g[u][v] = dd;
        g[v][u] = dd;
    }
    nanie();
    int kk = D;
    stack<int> ss;
    ss.push(D);
    while(pre[kk] != -1)
    {
        kk = pre[kk];
        ss.push(kk);
    }
    cout << dod[D] << " "<< mon[D] << endl;
    int ff = 0;
    while(!ss.empty())
    {
        if(!ff)
            ff = 1;
        else
            cout << " ";
        kk = ss.top();
        ss.pop();
        cout <<kk;
    }
}

7-17 修理牧场

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

int main()
{
    priority_queue<int, vector<int>, greater <int>> q;
    int n, i, x;
    cin >> n;
    for (i = 0; i < n; i++)
    {
        cin >> x;
        q.push(x);
    }
    int a, sum = 0;
    while (q.size() > 1)
    {
        a = q.top();
        q.pop();
        a += q.top();
        q.pop();

        q.push(a);
        sum += a;
    }
    cout << sum;
}

7-4 哈夫曼编码

7-8 装箱问题

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

int main()
{
    int n, i, j;
    cin >> n;
    int a[1005], s[1005];
    for (i = 1; i <= n; i++)
    {
        a[i] = 100;
        cin >> s[i];
    }
    for (i = 1; i <= n; i++)
    {
        for (j = 1; j <= n; j++)
        {
            if (s[i] <= a[j])
            { 
                a[j] -= s[i];
                cout << s[i] << " "<< j<< endl;
                break;
            }
        }
    }
    for (i = 1; i <= n; i++)
    {
        if (a[i] == 100)
            break;
    }
    if (i <= n)
        cout << i - 1<< endl;
    else
        cout << n << endl;
}

7-10 月饼

测试点2考察库存不为整数

信息全部定义为float
测试点3考察所有月饼库存总和不满足需求
if (i > n) break;

## include <bits/stdc++.h>
using namespace std;
struct mooncake{
    float num;
    float money;
    float aver;
}a[1005];
bool cmp(struct mooncake a , struct mooncake b)
{
    return a.aver > b.aver;
}
int main()
{
    int n, d, i, j;
    cin >> n >> d;
    for (i = 1; i <= n; i++)
        cin >> a[i].num;
    for (i = 1; i <= n; i++)
    { 
        cin >> a[i].money;
        a[i].aver = a[i].money  * 1.0 / a[i].num;
    }
    sort (1 + a, a + 1 + n, cmp);
    float sum = 0.00;
    i = 1;
    while (d > 0)
    {
        if (a[i].num >= d)
           { sum += a[i].aver * d; d = 0;}
        else
            {sum += a[i].aver * a[i].num; d -= a[i].num;}
        i++;
        if (i > n)
            break;
    }
    printf("%.2f", sum);
}

7-11 会场安排问题

数组开大一点

begin[i] < end[j]

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

int main()
{
    int n, i, begin[100005], end[100005];
    cin >> n;
    for (i = 0; i < n; i++)
        cin >> begin[i] >> end[i];
    sort (begin, begin + n);
    sort(end, end + n);
    int j = 0, ans = 0;
    for (i = 0; i < n; i++)
    {
        if (begin[i] < end[j]) // 如果开始时间小于结束时间, 会场数加1
            ans++;
        else  // 开始时间大于等于结束时间, 会场不用增加, 换下一家活动
            j++;
    }
    cout << ans << endl;
}

7-12 活动选择问题

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

typedef struct node
{
    int begin, end;
}Node;
Node a[101], t;

bool cmp(Node a, Node b)
{
    return a.end < b.end;
}
int main()
{
    vector <Node> v;
    int n, i, j;
    cin >> n;
    for (i = 0; i < n; i++)
    {
        cin >> t.begin >> t.end;
        v.push_back(t);
    }
    sort(v.begin(), v.end(), cmp);
    int num = v[0].begin, count = 0;
    for (i = 0; i < n; i++)
    {
        if (num <= v[i].begin)
        {
            num = v[i].end;
            count++;
        }
    }
    cout << count;
    return 0;
}

分治法

7-27 古老的汉诺塔

## include <bits/stdc++.h>
using namespace std;
int n, cut = 0;
void honi(int n, char a, char b, char c)
{
    cut++;
    if (n == 1)
        cout << a << "-->" << c << endl;
    else
    {
        honi(n - 1, a, c, b);
        cout << a << "-->" << c << endl;
        honi(n - 1, b, a, c);
    }
}
int main()
{
    cin >> n;
    honi(n, 'A', 'B', 'C');
    cout << cut;
}

7-28 士兵排队

## include <bits/stdc++.h>
using namespace std;
int n, i;
int main()
{
    cin >> n;
    int x[n], y[n];
    for (i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    sort(x, x + n);
    sort(y, y + n);
    int sum = 0;
    for (i = 0 ; i < n / 2; i++)
        sum += y[n - 1 - i] - y[i];
    for (i = 0; i < n; i++)
        x[i] -= i;
    sort(x, x + n);
    for (i = 0; i < n / 2; i++)
        sum += x[n - i - 1] - x[i];
    cout << sum;
}

7-29 输油管道问题

## include <bits/stdc++.h>
using namespace std;
int n, i, sum = 0;
int main()
{
    cin >> n;
    int x[n], y[n];
    for (i = 0; i < n; i++)
        cin >> x[i] >> y[i];
    sort(y, y + n);
    for (i = 0; i < n; i++)
        sum += fabs(y[i] - y[n / 2]);
    cout << sum;
}

7-6 第k小元素

## include <bits/stdc++.h>
using namespace std;
int n, i, sum = 0;
int main()
{
    int k;
    cin >> n >> k;
    int a[n];
    for (i = 0; i < n ; i++)
        cin >> a[i];
    sort(a, a + n);
    cout << a[k - 1];
}

7-34 幂次取余

快速幂

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

long long quickpow(long long  a, long long b, ll MOD)
{
    long long ans = 1;
    a %= MOD;
    while (b)
    {
        if (b % 2 == 1)
            ans = ans * a % MOD;
        b /= 2;
        a = a * a % MOD;
    }
    return ans;    
}
void solve()
{
    long long a, b, MOD;
    cin >> a >> b >> MOD;
    cout << quickpow(a, b, MOD) << endl;
}
int main()
{
    int T;
    cin >>T;
    while (T--)
        solve();
}

7-35 全排列（分治）

## include <bits/stdc++.h>
using namespace std;
void Fuck(int a[], int left, int right)
{
    int i, j;
    if (left == right)
    {
        for (i = 0; i <=right; i++)
            cout << a[i] << " ";
        cout << endl;
    }
    else
    {
        for (j = left; j <= right; j++)
        {
            swap(a[j], a[left]);
            Fuck(a, left + 1, right);
            swap(a[j], a[left]);
        }
    }
}
int main()
{
    int n, i;
    cin >> n;
    int a[n];
    for (i = 0; i < n; i++)
        a[i] = i + 1;
    Fuck(a, 0, n - 1);
}

7-36 抢红包

## include <bits/stdc++.h>
using namespace std;
typedef struct stu{
    int id;
    int getNum = 0;
    double getMoney = 0;
}Person;
bool cmp(Person a, Person b)
{
    if (a.getNum == b.getNum && a.getMoney == b.getMoney)
        return a.id < b.id;
    else if (a.getMoney == b.getMoney)
        return a.getNum > b.getNum;
    return a.getMoney > b.getMoney;
}
Person p[10005];
int main()
{
    int n, i, j, temp, x, y;
    cin >> n;
    for (i = 1; i <= n; i++)
    {
        cin >> temp;
        p[i].id = i;
        int sum = 0;
        while (temp--)
        {
            cin >> x >> y;

            p[i].getMoney -= y;
            p[x].getMoney += y;
            p[x].getNum++;
            sum += y;
        }
        //p[i].getMoney -=sum;
    }
    sort(p + 1, p + n + 1, cmp);
    for (i = 1; i<= n; i++)
    {
        cout << p[i].id << " ";
        printf("%.2lf\n", p[i].getMoney / 100);
    }
}

7-37 最大公约数和最小公倍数

## include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
int main()
{
    int a, b;
    cin >> a >> b;
    cout << gcd(a, b) <<" " << a / gcd(a,b) * b;
 }

7-38 求n以内最大的k个素数以及它们的和

## include <bits/stdc++.h>
using namespace std;
int Func(int a)
{
    int i;
    if (a == 1)
        return 0;
    for (i = 2; i <= a / 2; i++)
    {
        if (a % i == 0)
            return 0;
    }
    return 1;
}

int main()
{
    int n, k, sum = 0, count = 0;
    cin >> n >> k;
    int i, j;
    for (i = n - 1; i >= 1; i--)
    {
        if (Func(i))
        {
            count++;
            if (count == 1)
                cout << i;
            else
                cout << "+" << i;
            sum += i;
        }
        if (count == k)
            break;
    }
    cout << "=" << sum;
}

7-39 判断素数

注意YES no的形式

## include <iostream>
## include <cmath>
using namespace std;

int main()
{
    int n, m, i, j;
    cin >> n;
    for (i = 0; i < n; i++)
    {
        cin >> m;
        if (m == 1)
            puts("No");
        else
        {
            for (j = 2; j <= sqrt(m); j++)
                if (m % j == 0)
                    break;
            if (j > sqrt(m))
                puts("Yes");
            else
                puts("No");
        }
    }
    return 0;
}

7-40 C程序设计 实验4-3 欧几里得算法求最大公约数

把main复制

/* 请在这里完成 Gcd 函数*/

int Gcd(int a, int b)
{
    if (a == 0 && b == 0)
        return -1;
    if (a <= 0 || b < 0)
        return -1;
    if (b == 0)
        return a;
    return Gcd(b, a % b);
}

dp

7 - 1 租用游艇问题

#include <bits/stdc++.h>
using namespace std;
int a[500][500];
int dp[500];
int main()
{
    int n, i, j;
    cin >> n;
    for (i = 1; i < n; i++)
        for (j = i + 1; j <= n; j++)
            cin >> a[i][j];
    memset(dp, 0x3f, sizeof dp);
    dp[1] = 0;
    for (i = 1; i <= n; i++)
        for (j = i + 1; j <= n; j++)
            dp[j] = min(dp[j], dp[i] + a[i][j]);
    cout << dp[n] << endl;
}

7 - 2 矩阵链相乘问题

矩阵的乘法定义如下：设A是m×p的矩阵，B是p×n的矩阵，则A与B的乘积为m×n的矩阵，记作C=AB，其中，矩阵C中的第i行第j列元素cij​可以表示为：cij​=Σk=1p​aik​×bkj​=ai1​b1j​+ai2​b2j​+⋯+aip​bpj​.

当多个矩阵相乘时，采用不同的计算顺序所需的乘法次数不相同。例如，A是50×10的矩阵，B是10×20的矩阵，C是20×5的矩阵，
计算ABC有两种方式：(AB)C和A(BC)，前一种需要15000次乘法计算，后一种则只需3500次。

设A1​,A2​,…,An​为矩阵序列，Ai​是阶为Pi−1​∗Pi​的矩阵(1≤i≤n)。试确定矩阵的乘法顺序，使得计算A1​A2​…An​过程中元素相乘的总次数最少。

输入格式:
每个输入文件为一个测试用例，每个测试用例的第一行给出一个正整数n(1≤n≤100)，表示一共有n个矩阵A1​,A2​,…,An​，第二行给出n+1个整数P0​,P1​…Pn​，以空格分隔，其中1≤Pi​≤100(0≤i≤n)，第i个矩阵Ai​是阶为Pi−1​∗Pi​的矩阵。

输出格式:
获得上述矩阵的乘积，所需的最少乘法次数

#include <bits/stdc++.h>
using namespace std;
const int N = 2000;
int dp[N][N];
int a[N];
int main()
{
    int n;
    cin >> n;
    memset(dp, 0x3f, sizeof dp);
    for (i = 0; i <= n; i++)
        cin >> a[i], dp[i][i] = 0;
    for (int len = 2; len <= n; len++)
    {
        for (int l = 1; l + len - 1 <= n; l++)
        {
            int r = l + len - 1;
            for (int k = l; k < r; k++)
                dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + 1][r] + a[l - 1] * a[k] * a[r]);
        }
    }
    cout << dp[1][n] << endl;
}

7 - 3 字母表

我们定义一个小写字符串是“按字母表的”，当且仅当它删除掉一些字符后，可以变为”abcdefghijklmnopqrstuvwxyz”。
给定一个长度为n的小写字母字符串，至少插入多少个字符才能使其变成“按字母表的”。

输入格式:
输入第一行为一个整数T（1<=T<=100），代表测试数据的组数，随后T行，每行都是由小写字母’a’-'z’组成的一串字符s (1=<|n|<=50)。

输出格式:
输出为了让s变成“按字母表的”，至少要插入的字符个数，每组输出占一行。

#include <bits/stdc++.h>
using namespace std;
int dp[100];
string s;
int main()
{
    int t, i, j;
    cin >> t;
    while (t--)
    {
        cin >> s;
        int n = s.size();
        // memcpy (dp, 1, sizeof dp);
        for (i = 0; i < 100; i++)
            dp[i] = 1;
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < i; j++)
            {
                if ((int)s[i] > (int)s[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        int ans = 0;
        for (i = 1; i <= n; i++)
            ans = max(ans, dp[i]);
        cout << 26 - ans << endl;
    }
}

7 - 4 小H分糖果

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int a[N], b[N];
int main()
{
    int n;
    cin >> n;
    for (i = 1; i <= n; i++)
        cin >> a[i];
    for (i = 1; i < n; i++)
    {
        if (a[i + 1] > a[i])
            b[i + 1] = b[i] + 1;
    }
    for (i = n; i > 1; i--)
    {
        if (a[i - 1] > a[i])
            b[i - 1] = max(b[i - 1], b[i] + 1);
    }
    long long ans = 0;
    for (i = 1; i <= n; i++)
        ans += b[i];
    cout << ans + n << endl;
}

7 - 5 运动会

#include <bits/stdc++.h>
using namespace std;
const int N = 3010;
vector<int> a[N];
int root = 0, w[N], b[N];
int no[N], yes[N];
void dfs(int u)
{
    if (a[u].empty())
    {
        yes[u] = w[u];
        return;
    }
    yes[u] = w[u];
    for (i = 0; i < a[u].size(); i++)
    {
        dfs(a[u][i]);
        yes[u] += no[a[u][i]];
        no[u] += max(yes[a[u][i]], no[a[u][i]]);
    }
}
int main()
{
    int n;
    cin >> n;
    for (i = 1; i <= n; i++)
        cin >> w[i];
    for (i = 1; i < n; i++)
    {
        int x, y;
        cin >> x >> y;
        a[y].push_back(x);
        b[x] = y;
    }
    for (i = 1; i <= n; i++)
    {
        if (b[i] == 0)
            root = i;
    }
    // cout<<root<<endl;
    dfs(root);
    cout << max(no[root], yes[root]);
}

7 - 6 0-1背包

#include <bits/stdc++.h>
using namespace std;
int w[200], v[200], dp[1010];
int main()
{
    int n, c;
    cin >> n >> c;
    for (i = 1; i <= n; i++)
        cin >> w[i] >> v[i];
    for (i = 1; i <= n; i++)
        for (j = c; j >= w[i]; j--)
            dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
    cout << dp[c];
}

7 - 7 最长公共子序列长度

#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10;
int dp[N][N];
int main()
{
   string a, b;
   cin >> a >> b;
   a = " " + a;
   b = " " + b;
   for (i = 1; i < a.size(); i++)
   {
       for (j = 1; j < b.size(); j++)
       {
           dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
           if (a[i] == b[j])
               dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
       }
   }
   cout << dp[a.size() - 1][b.size() - 1];
}

7 - 8 单调递增最长子序列

#include <bits/stdc++.h>
using namespace std;
string s;
int dp[10005];
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        cin >> s;
        int len = s.length();
        memset(dp, 0, sizeof(dp));

        for (i = 0; i < len; i++)
        {
            dp[1] = 1;
            for (j = 0; j < i; j++)
            {
                if (s[i] > s[j])
                    dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        sort(dp, dp + len);
        printf("%d\n", dp[len - 1]);
    }
    return 0;
}

7 - 9 最长公共子序列

#include <bits/stdc++.h>
using namespace std;
int len = 0;
int a[100001], p[100001], f[100001];
int bound(int x)
{
    int L = 1, R = len;
    while (L < R)
    {
        int mid = (L + R) / 2;
        if (p[f[mid]] > p[x])
            R = mid;
        else
            L = mid + 1;
    }
    return L;
}
int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    for (int i = 1; i <= n; i++)
    {
        int x;
        cin >> x;
        p[x] = i;
    }
    for (int i = 1; i <= n; i++)
    {
        if (p[a[i]] > p[f[len]])
            f[++len] = a[i];
        else
            f[bound(a[i])] = a[i];
    }
    cout << len << endl;
    return 0;
}

7 - 10 最大连续子序列

#include <bits/stdc++.h>
using namespace std;
int a[1005];
int k, dp[1005], ans = -1;
int u, v = 1;

int main()
{
    while (cin >> k)
    {
        if (k == 0)
            return 0;
        for (i = 1; i <= k; i++)
            cin >> a[i];
            
        ans = -1;
        v = 1;
        for (i = 1; i <= k; i++)
        {
            dp[i] = max(dp[i - 1] + a[i], a[i]);
            if (ans < dp[i])
            {
                ans = dp[i];
                u = i;
            }
        }
        for (i = u; i >= 1; i--)
        {
            if (dp[i] < 0)
            {
                v = i + 1;
                break;
            }
        }
        if (ans == -1)
            cout << "0 " << a[1] << " " << a[k] << endl;
        else
            cout << ans << " " << a[v] << " " << a[u] << endl;
    }
    return 0;
}

7 - 11 数塔

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

int main()
{
    i, j, n;
    cin >> n;
    int a[n][n];
    for (i = 0; i < n; i++)
    {
        for (j = 0; j <= i; j++)
        {
            cin >> a[i][j];
        }
    }
    int dp[n][n];
    memset(dp, 0, sizeof dp);
    for (i = n - 2; i >= 0; i--)
    {
        for (j = 0; j <= i; j++)
        {
            a[i][j] = fmax(a[i + 1][j], a[i + 1][j + 1]) + a[i][j];
        }
    }
    cout << a[0][0] << endl;
    return 0;
}

7 - 12 石子合并 (链状)

#include <bits/stdc++.h>
using namespace std;
const int MAX = 1005;
const iNF = 0x3f3f3f3f;
int dp[MAX][MAX];
int sum[MAX];
int a[MAX];
i, j, n, len;
int main()
{
    cin >> n;
    memset(sum, 0, sizeof sum);
    memset(dp, INF, sizeof dp);
    for (i = 1; i <= n; i++)
    {
        cin >> a[i];
        sum[i] = sum[i - 1] + a[i];
        dp[i][i] = 0;
    }

    for (len = 1; len <= n; len++)
    {
        for (i = 1; i + len <= n + 1; i++)
        {
            int end = i + len - 1;
            for (j = i; j < end; j++)
            {
                dp[i][end] = fmin(dp[i][end], dp[i][j] + dp[j + 1][end] + sum[end] - sum[i - 1]);
            }
        }
    }
    cout << dp[1][n] << endl;
    return 0;
}

7 - 13 石子合并 (环)

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

int a[300], sum[300];
int Min[300][300], Max[300][300];
int main()
{
    int n, i;
    cin >> n;

    for (i = 1; i <= n; i++)
    {
        cin >> a[i];
        a[i + n] = a[i];
    }

    // 计算最大和
    for (i = 1; i <= 2 * n; i++)
        sum[i] = sum[i - 1] + a[i];

	for (i = 2 * n - 1; i >= 1; i--)
    {
    	for (j = i + 1; j < i + n; j++)
        {
            Min[i][j] = INF;
            for (int k = i; k < j; k++)
            {
                Min[i][j] = min(Min[i][j], Min[i][k] + Min[k + 1][j] + sum[j] - sum[i - 1]);
                Max[i][j] = fmax(Max[i][j], Max[i][k] + Max[k + 1][j] + sum[j] - sum[i - 1]);
            }
        }
    }

    int MaxValue = 0, MinValue = INF;
    for (i = 1; i <= n; i++)
    {
        MaxValue = fmax(MaxValue, Max[i][i + n - 1]);
        MinValue = fmin(MinValue, Min[i][i + n - 1]);
    }

    cout << MinValue << endl << MaxValue << endl;
}

7 - 14 超级楼梯1

#include <iostream>
using namespace std;

int f(int m)
{
    if (m == 1)
        return 1;
    else if (m == 2)
        return 1;
    else
        return f(m - 1) + f(m - 2);
}

int main()
{
    int n;
    cin >> n;
    int m;
    while (n--)
    { // 递推 站在高层往下推
        cin >> m;
        cout << f(m) << endl;
    }
    return 0;
}

7 - 18 一只小蜜蜂

#include <bits/stdc++.h>
int f(int a,int b)//因为紧邻的三个方块之间的路径有限，可以使用递归
{                   //b是指开始和终点间的距离
    if(b == 2)
        return 1;
    else if(b == 3)
        return 2;
    return f(1, b-1) + f(1, b-2);
}
int main()
{
    int n;
    int start,end;
    cin >> n;
    while(n--)
    {
    	cin >> start >> end;
        printf("%d\n",f(1,end-start+1));
    }
    return 0;
}

7 - 20 骨牌铺方格

#include <iostream>

using namespace std;

typedef long long LL;
LL dp[55];//防止越界

int main()
{
    int n;
    
    dp[1] = 1;
    dp[2] = 2;
    
    //打表 + 状态转移方程
    for (i = 3;i <= 55;i++) 
    	dp[i] = dp[i - 1] + dp[i - 2];
    
    while (cin >> n)
        cout << dp[n] << endl;
        
    return 0;
}

回溯法

1- 子集和问题

##include <bits/stdc++.h>
using namespace std;
int n, v, a[1000], ans[1000], cv;
bool flag = 0;

void Backsearch(int t)
{
    if (cv == 0)
    {
        flag = 1;
        return;
    }
    if (t > n)
        return;
    if (flag == 0 && a[t] <= cv)
    {
        cv -= a[t];
        ans[t] = a[t];
        Backsearch(t + 1);
        if (flag == 0)
        {
            cv += a[t];
            ans[t] = 0;
        }
    }
    if (flag == 0)
        Backsearch(t + 1);
}

int main()
{
    int i;
    cin >> n >> v;
    for (i = 1; i <= n; i++)
        cin >> a[i];
    cv = v;
    Backsearch(1);
    if (flag == 1)
    {
        for (i = 1; i <= n; i++)
        {
            if (ans[i])
                cout << ans[i] << " ";
        }
    }
    else
        cout << "No Solution!";
    return 0;
}

2- 八皇后问题

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

const int maxn = 200;
int sum, n, cnt;
int C[maxn];
bool vis[3][maxn];
int Map[maxn][maxn]; // 打印解的数组

void Backtrack(int cur) // 逐行放置皇后
{
    i, j;
    cnt++;
    if (cur == n)
    {
        sum++;
        if (sum > 1)
            cout << '\n';
        for (i = 0; i < cur; i++)
            Map[i][C[i]] = 1; 
        for (i = 0; i < n; i++)
        {
            for (j = 0; j < n; j++)
            {
                if (Map[i][j])
                    cout << "Q";
                else
                    cout << ".";
                if (j == n - 1)
                    cout << endl;
                else
                    cout << " ";
            }
        }
        memset(Map, 0, sizeof(Map)); // 还原
    }
    else
        for ( i = 0; i < n; i++) // 尝试在 cur行的 各 列 放置皇后
        {
            if (!vis[0][i] && !vis[1][cur + i] && !vis[2][cur - i + n]) // 判断当前尝试的皇后的列、主对角线
            {
                vis[0][i] = vis[1][cur + i] = vis[2][cur - i + n] = true;
                C[cur] = i; // cur 行的列是 i
                Backtrack(cur + 1);
                vis[0][i] = vis[1][cur + i] = vis[2][cur - i + n] = false; // 切记！一定要改回来
            }
        }
}

int main()
{
    cin >> n;
    memset(vis, false, sizeof(vis));
    memset(Map, 0, sizeof(Map));
    sum = cnt = 0;
    Backtrack(0);
    if (!sum)
        cout << "None\n";
    return 0;
}

3- 0-1背包

4- 工作分配问题

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

int n;
int pay[21][21];   // pay[i][j]表示将工作i分配给第j个人的费用为pay[i][j]
int Min = INT_MAX; // 初始化为最大整数
int sum = 0;       // 得到的工作费用和
int book[21];      // book[i]=0表示没有被分配工作；book[i]=1表示已经被分配工作

void Backtrack(int t)
{
    if (t >= n) // 已经到达叶子结点，继续判断是否找到了最小总费用
    {
        if (Min > sum) // 没有找到最小总费用
        {
            Min = sum; // 更新最小总费用
            return;
        }
    }
    for (i = 0; i < n; i++) // 为第工作t安排人
    {
        if (!book[i]) // 第i个人还没有被安排工作
        {
            book[i] = 1;      // 将工作t分配给第i个人
            sum += pay[t][i]; // 更新总费用
            if (sum < Min)    // 如果当前得到的sum小于最小值，就向下搜索子树；否则剪枝
                Backtrack(t + 1);
            book[i] = 0; // 没有得到比Min更小的和，回溯
            sum -= pay[t][i];
        }
    }
}

int main()
{
    cin >> n;
    for (i = 0; i < n; i++)
    {
        for (j = 0; j < n; j++)
        {
            cin >> pay[i][j];
        }
        book[i] = 0;
    }
    Backtrack(0);
    cout << Min << endl;
    return 0;
}

5- 德邦国王

在oj上自测运行过不去，直接提交就好

##include <bits/stdc++.h>
using namespace std;
const int N = 100;
int a[N], b[N], f1[N][N], f2[N][N];
int n, k, m, X, Y;
int ans = 0x3f3f3f3f;

void dfs(int x, int y, int u)
{
    int s = 0, i, j;
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
            if (f1[i][j] != f2[i][j])
                s++;
    if (s == 0)
    {
        ans = fmin(ans, u);
        return;
    }
    if (u > ans)
        return;
    if (s > m - u)
        return;
    for (i = 0; i < k; i++)
    {
        int dx = x + a[i], dy = y + b[i];
        if (dx > 0 && dx <= n && dy > 0 && dy <= n)
        {
            swap(f1[x][y], f1[dx][dy]);
            dfs(dx, dy, u + 1);
            swap(f1[x][y], f1[dx][dy]);
        }
    }
}
int main()
{
    cin >> n >> k >> m;
    i, j;
    for (i = 0; i < k; i++)
        cin >> a[i] >> b[i];
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
        {
            cin >> f1[i][j];
            if (f1[i][j] == 2)
                X = i, Y = j;
        }
    for (i = 1; i <= n; i++)
        for (j = 1; j <= n; j++)
            cin >> f2[i][j];
    dfs(X, Y, 0);
    if (ans > m)
        cout << -1;
    else
        cout << ans;
}

6- 图着色问题

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

const int N = 1010;
int m[N][N], c[N];

int main()
{
    int vertexNum, edgeNum, colorNum;
    cin >> vertexNum >> edgeNum >> colorNum;
    while (edgeNum--)
    {
        int a, b;
        cin >> a >> b;
        m[a][b] = m[b][a] = 1;
    }
    int n, i, j;
    cin >> n;
    while (n--)
    {
        bool st[N] = {0}, flag = true;
        int num = 0;
        for (i = 1; i <= vertexNum; i++)
        {
            cin >> c[i];
            if (!st[c[i]])
                num++, st[c[i]] = 1;
        }
        if (num != colorNum)
        {
            cout << "No" << endl;
            continue;
        }
        for (i = 1; i <= vertexNum; i++)
        {
            for (j = 1; j <= vertexNum; j++)
            {
                if (m[i][j] && c[i] == c[j])
                {
                    flag = false;
                    break;
                }
            }
        }
        if (flag)
            cout << "Yes" << endl;
        else
            cout << "No" << endl;
    }
}

7- 最大团问题

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

const int N = 55;
bool g[N][N];
vector<int> v;
int n, ans;

bool check(int x)
{
    for (auto i : v) // for each i in v
        if (!g[i][x])
            return 0;
    return 1;
}

void dfs(int x, int cnt)
{
    ans = max(ans, cnt);
    for (i = x + 1; i <= n; i++)
        if (check(i))
        {
            v.push_back(i);
            dfs(i, cnt + 1);
            v.pop_back();
        }
}

int main()
{
    i, j;
    while (cin >> n)
    {
        if (n == 0)
            break;
        ans = 0;
        for (i = 1; i <= n; i++)
            for (j = 1; j <= n; j++)
                cin >> g[i][j];
        for (i = 1; i <= n; i++)
        {
            v.push_back(i);
            dfs(i, 1);
            v.clear();
        }
        cout << ans << endl;
    }
}

9- 拯救007

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

struct node
{
    int x, y;
} p[110];
int vis[110];
int flag = 0;
int n, m;
int Get(int x)
{
    if ((p[x].x - m <= -50) || (p[x].x + m >= 50) || (p[x].y - m <= -50) || (p[x].y + m >= 50))
        return 1;
    return 0;
}
int first(int x)
{
    int p1 = pow(p[x].x, 2);
    int p2 = pow(p[x].y, 2);
    int r = (m + 7.5) * (m + 7.5);
    if (p1 + p2 <= r)
        return 1;
    return 0;
}
int jump(int x, int y)
{
    int p1 = pow(p[x].x - p[y].x, 2);
    int p2 = pow(p[x].y - p[y].y, 2);
    int r = m * m;
    if (p1 + p2 <= r)
        return 1;
    return 0;
}
int dfs(int t)
{
    vis[t] = 1;
    if (Get(t) == 1)
    {
        flag = 1;
    }
    for (i = 0; i < n; i++)
    {
        if (!vis[i] && jump(t, i))
            flag = dfs(i);
    }
    return flag;
}
int main()
{
    memset(vis, 0, sizeof(vis));
    cin >> n >> m;
    i;
    for (i = 0; i < n; i++)
        cin >> p[i].x >> p[i].y;

    if (m >= 42.5)
        cout << "Yes" << endl;
    else
    {
        for (i = 0; i < n; i++)
        {
            if (!vis[i] && first(i))
                dfs(i);
        }
        if (flag == 1)
            cout << "Yes" << endl;
        else
            cout << "No" << endl;
    }
    return 0;
}

10- 列出连通集

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

typedef long long ll;
int v, e;
int vis[15], g[15][15];
queue<int> q;

void dfs(i)
{
    vis[i] = 1;
    cout << " " << i;
    for (j = 0; j < v; j++)
    {
        if (!vis[j] && g[i][j])
        {
            dfs(j);
        }
    }
}

void bfs(i)
{
    q.push(i);
    vis[i] = 1;
    while (!q.empty())
    {
        for (int j = 0; j < v; j++)
        {
            if (!vis[j] && g[q.front()][j])
            {
                vis[j] = 1;
                q.push(j);
            }
        }
        cout << " " << q.front();
        q.pop();
    }
}

int main()
{
    int x, y;
    cin >> v >> e;
    for (i = 0; i < e; i++)
    {
        cin >> x >> y;
        g[x][y] = g[y][x] = 1;
    }
    memset(vis, 0, sizeof(vis));
    for (i = 0; i < v; i++)
    {
        if (!vis[i])
        {
            cout << "{";
            dfs(i);
            cout << " }" << endl;
        }
    }
    memset(vis, 0, sizeof(vis));
    for (i = 0; i < v; i++)
    {
        if (!vis[i])
        {
            cout << "{";
            bfs(i);
            cout << " }" << endl;
        }
    }
    return 0;
}

11- 深入虎穴

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

const int N = 100010;
int vis[N], Max = -1, ans;
vector<int> v[N];

void dfs(int x, int n)
{
    if (n > Max)
    {
        Max = n;
        ans = x;
    }
    for (int i = 0; i < v[x].size(); i++)
        dfs(v[x][i], n + 1);
}
int main()
{
    int n, k, x;
    cin >> n;
    for (int i = 1; i <= n; i++)
    {
        cin >> k;
        while (k--)
        {
            cin >> x;
            v[i].push_back(x);
            vis[x] = 1;
        }
    }
    int root = 1;
    while (root <= n && vis[root] != 0)
        root++;
    dfs(root, 0);
    cout << ans << endl;
    return 0;
}

12- 六度空间

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

##define MAX INT_MAX
int n, m, i, j, k;

int main()
{
    cin >> n >> m;
    int edge[n + 1][n + 1];
    for (i = 0; i < n + 1; i++)
    {
        for (j = 0; j < n + 1; ++j)
        {
            edge[i][j] = MAX;
            if (i == j)
                edge[i][j] = 0;
        }
    }
    for (i = 0; i < m; ++i)
    {
        int x, y;
        cin >> x >> y;
        edge[x][y] = 1;
        edge[y][x] = 1;
    }
    for (k = 1; k <= n; k++)
    {
        for (i = 1; i <= n; i++)
        {
            for (j = 1; j <= n; j++)
            {
                if (edge[i][j] > edge[i][k] + edge[k][j])
                {
                    edge[i][j] = edge[i][k] + edge[k][j];
                }
            }
        }
    }
    for (j = 1; j <= n; j++)
    {
        int cnt = 1;
        for (i = 1; i <= n; i++)
        {
            if (edge[i][j] <= 6 && i != j)
                cnt++;
        }
        printf("%d: %.2f%%\n", j, 1.0 * cnt * 100 / n);
    }
}

13- 输出全排列

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

int a[10];
int main()
{
    int n, i, j = 1, k;
    cin >> n;
    for (i = 1; i <= n; i++)
    {
        a[i] = n - i + 1;
        j *= i;
    } 
    for (i = 1; i <= j; i++)
    {
        next_permutation(a + 1, a + n + 1);
        for (k = 1; k <= n; k++)
            cout << a[k];
        cout << endl;
    }
}