PTA题目测试

已于 2024-01-31 20:35:34 修改
阅读量387 收藏 7
点赞数 5
分类专栏： PTA测试 文章标签： 算法 深度优先
于 2024-01-16 11:48:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hinton_/article/details/135621054
版权

函数

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;
    }
}
Hinton_
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一些PTA题目经验总结
Verniey的博客
02-23 2175
一些PTA题目经验总结 （1） 6-10 阶乘计算升级版 题目要求 本题要求实现一个打印非负整数阶乘的函数。 函数接口定义： void Print_Factorial ( const int N ); 其中N是用户传入的参数，其值不超过1000。如果N是非负整数，则该函数必须在一行中打印出N!的值，否则打印“Invalid input”。 裁判测试程序样例： #include &lt;s...
PTA 题目：找“重点”
Tutututu0pay的博客
12-23 1124
在一个N×N的矩阵中，如果某个元素的值大于其上下左右四个相邻元素之和，则本题称这个元素为“重点”。本题要求寻找给定矩阵中的所有“重点”。 需要注意的是： 矩阵中元素的坐标采用(x,y)的形式，x为元素所在的行号、y为元素所在的列号，x和y均从0开始 矩阵的行号由上至下增长；列号从左到右增长 最上方一行的元素，其“上方”相邻元素，位于同列的最下方一行 最下方一行的元素，其“下方”相邻元素，位于同列的最上方一行 最左方一列的元素，其“左方”相邻元素，位于同行的最右方一列 最右方一列的元素，其“右方
PTA题目 幸运彩票
m0_75115594的博客
11-17 663
PTA题目 幸运彩票
PTA试题
DrewLee的博客
09-25 570
本题要求实现一个函数，对给定的正整数N，打印从1到N的全部正整数。 void PrintN ( int N ); 其中N是用户传入的参数。该函数必须将从1到N的全部正整数顺序打印出来，每个数字占1行。 裁判测试程序样例： #include <stdio.h> void PrintN ( int N ); int main () { int N; scanf("%d", &N); PrintN( N ); return 0; } void PrintN(int N) { int i;
PTA考试题
weixin_46753005的博客
06-21 2947
使用函数求特殊a串数列和 def fn(m, n): sum=res=0 for i in range(1, n+1): sum=sum+m m=m*10 res=res+sum return res 使用函数统计指定数字的个数 def CountDigit(number,digit ): number=str(number) return number.count(str(digit)) 使用函数求素数和 def isPr
三只松鼠组 pta题目.zip
04-29
"三只松鼠组 pta题目.zip"这个压缩包，似乎是一个专门为编程爱好者或者学生设计的练习集，其中包含了两个文件：《三只松鼠组 到底吃不吃.txt》和《三只松鼠组-测试用例.zip》。这些题目旨在帮助学习者深化对算法的...
PTA 团体设计天梯赛题解L1（水）
01-23
在PTA题目中，你需要学会正确处理输入输出格式。 4. **字符串操作**：在L1阶段，你可能会遇到关于字符串的基本操作，如比较、复制、查找子串等。了解字符串的基本函数和操作方法是必要的。 5. **逻辑推理**：很多...
pta：PTA平台刷题
02-20
在刷题过程中，理解题目的要求，设计合适的算法，编写清晰的代码，以及充分的测试是必不可少的。通过PTA平台，学生可以不断地挑战自己，提升编程能力，同时也可以参与在线竞赛，与其他程序员一较高下。记住，持续的...
code_pta_
10-03
每一道PTA题目通常涉及到不同的编程知识点，如数据结构（数组、链表、栈、队列、树等）、算法（排序、搜索、动态规划、贪心算法等）、基础编程概念（变量、控制流、函数、输入/输出等）以及特定问题的解决策略。...
1_pta_
10-02
"针对入门练习的题目一些ac代码分享"意味着这个压缩包包含的是该平台上一些入门级别的习题解法，这些解法已经通过了平台的自动判题系统（通常称为AC，Accepted），即代码是正确并能通过所有测试用例的。 【标签】：...
算法-KMP字符串匹配
xx_xb的博客
07-23 174
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 395
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
AtCoder Beginner Contest 363
2301_80105412的博客
07-21 648
AtCoder Beginner Contest 363 ABCDE
算法力扣刷题记录 五十八【701.二叉搜索树中的插入操作】
最新发布
danaaaa的博客
07-24 746
二叉搜索树向左或向右指明方向，不用遍历整个树。
2024.7.19 刷题总结
TheJustice_的博客
07-19 309
543.二叉树的直径，这道题是一道考察递归的题目，按照树的一般算法，维护一个最大直径答案值，定义一个递归函数，开头是递归返回条件，即当前节点为空节点就返回0，否则分别往左和往右递归，维护每个节点的最大深度为左右最大深度中的最大值再加一，答案用左右节点的最大深度的和再加一来维护.124.二叉树中的最大路径和，这是一道考察递归的题目，从根节点出发，类似于dfs，分别递归寻找左右节点的路径和，直到叶子节点再返回，从叶子节点往上更新以每个节点为根节点的最大路径，直到返回根节点，用一个变量来维护答案.
插入和选择排序
c23856的博客
07-20 538
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
Python鲁汶意外莱顿复杂图拓扑分解算法
跨学科知识视角展现
07-24 750
:dart:算法池化和最佳分区搜索：:pen:网格搜索 | :pen:发现算法池 | :pen:返回指定图的最佳划分 | :pen:返回指定图的最佳分区 | :dart:适应度和聚类比较功能：:pen:图的划分 | :pen:节点度 | :pen:给定算法检测到社群总数 | :pen:图密度 | :pen:社群顶点的度数之和 | :pen:解之间的预期一致 | :pen:联合熵 | :pen:平均内部度、所有可能的节点对的平均路径长度 | :pen:节点指向社群外的边平均比例 | :pen:现有边距离社群比
【常微分方程】
qq_74285286的博客
07-24 250
常微分方程笔记
python实现图像缩放算法
qq_42568323的博客
07-20 403
它通过选择离目标像素最近的原始像素的颜色值来确定目标像素的颜色值。它通过考虑目标像素周围16个像素的颜色值，使用双三次插值公式计算出目标像素的颜色值。相较于双线性插值，双三次插值能生成更平滑、更细腻的图像效果。它通过考虑目标像素周围四个像素的颜色值，使用双线性插值公式计算出目标像素的颜色值。尽管最近邻插值在某些应用场景中足够使用，但在需要更高质量图像的场景中，通常会选择更加复杂的插值方法，如双线性插值或双三次插值。双三次插值是图像缩放中高质量的方法之一，适合需要高质量图像处理的应用场景。
连续因子pta测试用例
03-06
连续因子是指在一个正整数序列中，存在一段连续的子序列，使得子序列中的所有元素的乘积是一个完全平方数。PTA（Programming Test Assistant）是一个在线编程练习平台，提供了各种编程题目供学习和练习。 下面是一个连续因子的PTA测试用例的示例： 输入： 5 1 2 3 4 5 输出： 2 解释： 在给定的序列中，存在一个连续子序列[2, 3]，其乘积为6，是一个完全平方数。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值