桃黑黑反斗战

最新推荐文章于 2025-12-20 17:21:30 发布
原创 最新推荐文章于 2025-12-20 17:21:30 发布 · 444 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

1.编写求解Hanoi汉诺塔的递归算法代码，输出移动过程，并统计总移动次数。 对不同规模的汉诺塔，给出测试的结果

#include <stdio.h>
#include <time.h>
int moveCount = 0;
void hanoi(int n,char source,char auxiliary,char target) {
    if (n==1) {
        moveCount++;  
        printf("Move disk 1 from %c to %c\n", source, target);
        return;
    }
    hanoi(n - 1, source, target, auxiliary);
    moveCount++;
    printf("Move disk %d from %c to %c\n", n, source, target);
    hanoi(n - 1, auxiliary, source, target);
}
int main() {
    int n;
    printf("Enter the number of disks: ");
    scanf("%d", &n);
    clock_t start_time = clock();
    hanoi(n, 'A', 'B', 'C');
    printf("Total moves: %d\n", moveCount);
    clock_t end_time = clock();
    double time_taken = ((double)(end_time - start_time)) / CLOCKS_PER_SEC;
    printf("Total moves: %d\n", moveCount);
    printf("Time taken: %f seconds\n", time_taken);
    double theoretical_moves = (1 << n) - 1; 
    printf("Theoretical moves (2^%d-1): %f\n", n, theoretical_moves);
    return 0;
}

2.编写程序实现2个有序数组的合并，并输出基本操作（比较、移动）的次数。

#include <stdio.h>
void merge(int a[], int n1, int b[], int n2, int c[], int *comp, int *move);
int main() {
    int n1, n2;
    printf("请输入第一个数组的大小: ");
    scanf("%d", &n1);
    int a[n1];
    printf("请输入第一个数组的元素: ");
    for (int i = 0; i < n1; i++) {
        scanf("%d", &a[i]);
	}
    printf("请输入第二个数组的大小: ");
    scanf("%d", &n2);
    int b[n2];
    printf("请输入第二个数组的元素: ");
    for (int i = 0; i < n2; i++) {
        scanf("%d", &b[i]);
    }
    int c[n1 + n2];
    int comp = 0, move = 0;
    merge(a, n1, b, n2, c, &comp, &move);
    printf("合并后的数组: ");
    for (int i = 0; i < n1 + n2; i++) {
        printf("%d ", c[i]);
    }
    printf("\n");
    printf("比较操作次数: %d\n", comp);
    printf("移动操作次数: %d\n", move);
    return 0;
}
void merge(int a[], int n1, int b[], int n2, int c[], int *comp, int *move) {
    int i = 0, j = 0, k = 0;
    while (i < n1 && j < n2) {
        (*comp)++;  
        if (a[i] < b[j]) {
            c[k++] = a[i++];  
            (*move)++;
        } else {
            c[k++] = b[j++];  
            (*move)++;
        }
    }
    while (i < n1) {
        c[k++] = a[i++];  
        (*move)++;
    }
    while (j < n2) {
        c[k++] = b[j++];  
        (*move)++;
    }
}

3.使用蛮力法计算平面上最接近的两点之间的距离，理解O(n^2)时间复杂度的影响

#include <iostream>
#include <vector>
#include <cmath>
#include <limits>
#include <cstdlib>
#include <ctime>
using namespace std;
struct Point {
    double x, y;
    Point(double a, double b) {
        x = a;
        y = b;
    }
};
int main() {
    srand(time(0)); 
    int numPoints = 10; 
    vector<Point> points; 
    for (int i = 0; i < numPoints; i++) {
        double x = rand() % 100; 
        double y = rand() % 100;
        points.push_back(Point(x, y)); 
    }
    cout << "随机生成的点：" << endl; 
    for (size_t i = 0; i < points.size(); i++) { 
        cout << "(" << points[i].x << ", " << points[i].y << ")" << endl;
    }
    double minDist = numeric_limits<double>::max(); 
    for (int i = 0; i < numPoints; i++) {
        for (int j = i + 1; j < numPoints; j++) { 
            double dx = points[i].x - points[j].x;
            double dy = points[i].y - points[j].y;
            double dist = sqrt(dx * dx + dy * dy); 
            if (dist < minDist) {
                minDist = dist;
            }
        }
    }
    cout << "最近两点之间的最短距离：" << minDist << endl;
    return 0;
}

4.求有序数组中两个数的和等于目标值

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    int left = 0;
    int right = numsSize - 1;

    int* result = (int*)malloc(2 * sizeof(int));
    if (result == NULL) {
        return NULL;
    }

    while (left < right) {
        int sum = nums[left] + nums[right];
        if (sum == target) {
            result[0] = left;
            result[1] = right;
            *returnSize = 2;
            return result;
        } else if (sum < target) {
            left++;
        } else {
            right--;
        }
    }

    *returnSize = 0;
    free(result);
    return NULL;
}
void parseInput(const char* input, int** nums, int* numsSize, int* target) {
    char* temp = strdup(input);
    char* token = strtok(temp, "=[], ");
    token = strtok(NULL, "=[], ");
    *numsSize = 0;
    while (token != NULL && strcmp(token, "target") != 0) {
        (*numsSize)++;
        token = strtok(NULL, "=[], ");
    }
    *nums = (int*)malloc(*numsSize * sizeof(int));
    if (*nums == NULL) {
        printf("内存分配失败\n");
        exit(1);
    }
    token = strtok(temp, "=[], ");
    token = strtok(NULL, "=[], ");
    for (int i = 0; i < *numsSize; i++) {
        (*nums)[i] = atoi(token);
        token = strtok(NULL, "=[], ");
    }
    token = strtok(NULL, "=[], ");
    *target = atoi(token);

    free(temp);
}
int main() {
    char input[1000];
    printf("请按照 nums=[1, 3, 5, 7, 9], target=10 的格式输入: ");
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0; 
    int* nums;
    int numsSize;
    int target;
    parseInput(input, &nums, &numsSize, &target);
    int returnSize;
    int* result = twoSum(nums, numsSize, target, &returnSize);
    if (result != NULL) {
        printf("[%d, %d]\n", result[0], result[1]);
        free(result);
    } else {
        printf("未找到符合条件的两个数\n");
    }
    free(nums);
    return 0;
}

5.给定一组物品，每个物品有一个重量和一个价值。背包有一个最大承重限制。目标是从这些物品中选择一部分装入背包，使得背包中物品的总价值最大。与0/1背包问题不同，分数背包问题允许将物品分割成任意大小（即可以选择物品的一部分装入背包）。//输入：物品数量 n、每个物品的重量和价值 、背包的最大承重W

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

typedef struct {
    int weight;
    int value;
    double ratio;
} Item;
int compare(const void *a, const void *b) {
    Item *itemA = (Item *)a;
    Item *itemB = (Item *)b;
    if (itemA->ratio < itemB->ratio)
        return 1;
    else if (itemA->ratio > itemB->ratio)
        return -1;
    return 0;
}
double fractionalKnapsack(int n, Item items[], int capacity) {
    for (int i = 0; i < n; i++) {
        items[i].ratio = (double)items[i].value / items[i].weight;
    }
    qsort(items, n, sizeof(Item), compare);
    double totalValue = 0.0;
    int currentCapacity = capacity;
    for (int i = 0; i < n; i++) {
        if (currentCapacity >= items[i].weight) {
            totalValue += items[i].value;
            currentCapacity -= items[i].weight;
        } else {
            totalValue += currentCapacity * items[i].ratio;
            break;
        }
    }
    return totalValue;
}
int main() {
    int n, capacity;
    printf("请输入物品的数量: ");
    scanf("%d", &n);
    Item *items = (Item *)malloc(n * sizeof(Item));
    if (items == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    printf("请依次输入每个物品的重量和价值:\n");
    for (int i = 0; i < n; i++) {
        scanf("%d %d", &items[i].weight, &items[i].value);
    }
    printf("请输入背包的最大承重: ");
    scanf("%d", &capacity);
    double maxValue = fractionalKnapsack(n, items, capacity);
    printf("背包中物品的最大总价值为: %.2f\n", maxValue);
    free(items);
    return 0;
}

6.在区间调度问题中，给定 n 个作业，每个作业由一个时间区间 [s_i, f_i]（s_i 为开始时间，f_i 为结束时间）表示。每个作业互不兼容（即不能同时运行两个作业）。目标是在不重叠的情况下安排最多的作业。

#include <stdio.h>
#include <stdlib.h>
typedef struct {
    int start;
    int end;
    int index;
} Job;
int compare(const void *a, const void *b) {
    Job *jobA = (Job *)a;
    Job *jobB = (Job *)b;
    return jobA->end - jobB->end;
}
int main() {
    int n;
    printf("请输入任务数: ");
    scanf("%d", &n);
    Job *jobs = (Job *)malloc(n * sizeof(Job));
    if (jobs == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
    // 输入每个作业的开始和结束时间
    for (int i = 0; i < n; i++) {
        printf("请输入第 %d 个作业的开始时间和结束时间: ", i + 1);
        scanf("%d %d", &jobs[i].start, &jobs[i].end);
        jobs[i].index = i + 1;
    }
    // 按结束时间排序
    qsort(jobs, n, sizeof(Job), compare);
    int selectedJobs[100];
    int count = 0;
    // 选择第一个作业
    selectedJobs[count++] = jobs[0].index;
    int prevEnd = jobs[0].end;
    // 贪心选择作业
    for (int i = 1; i < n; i++) {
        if (jobs[i].start >= prevEnd) {
            selectedJobs[count++] = jobs[i].index;
            prevEnd = jobs[i].end;
        }
    }
    // 输出结果
    printf("选出的作业个数: %d\n", count);
    printf("选出的作业序列: ");
    for (int i = 0; i < count; i++) {
        printf("%d ", selectedJobs[i]);
    }
    printf("\n");
    free(jobs);
    return 0;
}

7.

7.1选择邻接矩阵或邻接表作为图的存储结构.使用 Prim 算法求解最小生成树。输出最小生成树的总权值和具体选取的边。

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>  // 添加这一行
// 找到距离最小生成树最近且未被包含的顶点
int minKey(int key[], int mstSet[], int V) {
    int min = INT_MAX, min_index;
    for (int v = 0; v < V; v++) {
        if (mstSet[v] == 0 && key[v] < min) {
            min = key[v];
            min_index = v;
        }
    }
    return min_index;
}
// 打印最小生成树
void printMST(int parent[], int **graph, int V) {
    int total_weight = 0;
    printf("Edge \tWeight\n");
    for (int i = 1; i < V; i++) {
        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
        total_weight += graph[i][parent[i]];
    }
    printf("Total weight of MST: %d\n", total_weight);
}
// Prim 算法实现
void primMST(int **graph, int V) {
    int *parent = (int *)malloc(V * sizeof(int));  // 存储最小生成树中每个顶点的父节点
    int *key = (int *)malloc(V * sizeof(int));     // 存储每个顶点到最小生成树的最小权值
    int *mstSet = (int *)malloc(V * sizeof(int));  // 标记顶点是否已被包含在最小生成树中
    // 初始化所有顶点的 key 值为无穷大，mstSet 为 false
    for (int i = 0; i < V; i++) {
        key[i] = INT_MAX;
        mstSet[i] = 0;
    }
    // 从顶点 0 开始构建最小生成树
    key[0] = 0;
    parent[0] = -1;  // 顶点 0 是根节点，没有父节点
    // 构建最小生成树，直到包含所有顶点
    for (int count = 0; count < V - 1; count++) {
        // 找到距离最小生成树最近且未被包含的顶点
        int u = minKey(key, mstSet, V);
        // 将该顶点标记为已包含在最小生成树中
        mstSet[u] = 1;
        // 更新与该顶点相邻且未被包含的顶点的 key 值和父节点
        for (int v = 0; v < V; v++) {
            if (graph[u][v] && mstSet[v] == 0 && graph[u][v] < key[v]) {
                parent[v] = u;
                key[v] = graph[u][v];
            }
        }
    }
    // 打印最小生成树
    printMST(parent, graph, V);
    // 释放动态分配的内存
    free(parent);
    free(key);
    free(mstSet);
}
int main() {
    int V;
    printf("请输入图的顶点数量: ");
    scanf("%d", &V);
    // 动态分配邻接矩阵的内存
    int **graph = (int **)malloc(V * sizeof(int *));
    for (int i = 0; i < V; i++) {
        graph[i] = (int *)malloc(V * sizeof(int));
    }
    printf("请输入图的邻接矩阵（%d x %d）:\n", V, V);
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            scanf("%d", &graph[i][j]);
        }
    }
    // 调用 Prim 算法求解最小生成树
    primMST(graph, V);
    // 释放邻接矩阵的内存
    for (int i = 0; i < V; i++) {
        free(graph[i]);
    }
    free(graph);
    return 0;
}

7.2进阶：采用优先队列（堆优化）版本的Prim算法，提高效率。

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
// 定义一个结构体来表示图的边
typedef struct {
    int vertex;
    int weight;
} Edge;
// 定义一个结构体来表示优先队列的元素
typedef struct {
    int vertex;
    int key;
} QueueElement;
// 交换两个队列元素
void swap(QueueElement *a, QueueElement *b) {
    QueueElement temp = *a;
    *a = *b;
    *b = temp;
}
// 最小堆化
void minHeapify(QueueElement *heap, int *pos, int n, int i) {
    int smallest = i;
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    if (left < n && heap[left].key < heap[smallest].key)
        smallest = left;
    if (right < n && heap[right].key < heap[smallest].key)
        smallest = right;
    if (smallest != i) {
        // 更新位置数组
        pos[heap[smallest].vertex] = i;
        pos[heap[i].vertex] = smallest;
        swap(&heap[smallest], &heap[i]);
        minHeapify(heap, pos, n, smallest);
    }
}
// 从堆中提取最小元素
QueueElement extractMin(QueueElement *heap, int *pos, int *n) {
    QueueElement root = heap[0];
    QueueElement last = heap[*n - 1];
    // 将最后一个元素移到根节点
    heap[0] = last;
    // 更新位置数组
    pos[root.vertex] = *n - 1;
    pos[last.vertex] = 0;
    // 减小堆的大小
    (*n)--;
    // 最小堆化
    minHeapify(heap, pos, *n, 0);
    return root;
}
// 减小某个顶点的 key 值
void decreaseKey(QueueElement *heap, int *pos, int n, int v, int key) {
    int i = pos[v];
    heap[i].key = key;
    while (i && heap[i].key < heap[(i - 1) / 2].key) {
        // 更新位置数组
        pos[heap[i].vertex] = (i - 1) / 2;
        pos[heap[(i - 1) / 2].vertex] = i;
        swap(&heap[i], &heap[(i - 1) / 2]);
        i = (i - 1) / 2;
    }
}
// 检查顶点是否在堆中
int isInHeap(int *pos, int v, int n) {
    return pos[v] < n;
}

// 打印最小生成树
void printMST(int parent[], int **graph, int V) {
    int total_weight = 0;
    printf("Edge \tWeight\n");
    for (int i = 1; i < V; i++) {
        printf("%d - %d \t%d \n", parent[i], i, graph[i][parent[i]]);
        total_weight += graph[i][parent[i]];
    }
    printf("Total weight of MST: %d\n", total_weight);
}
// 堆优化的 Prim 算法
void primMST(int **graph, int V) {
    int *parent = (int *)malloc(V * sizeof(int));  // 存储最小生成树中每个顶点的父节点
    int *key = (int *)malloc(V * sizeof(int));     // 存储每个顶点到最小生成树的最小权值
    int *pos = (int *)malloc(V * sizeof(int));     // 存储每个顶点在堆中的位置
    QueueElement *heap = (QueueElement *)malloc(V * sizeof(QueueElement));
    // 初始化所有顶点的 key 值为无穷大，parent 为 -1
    for (int i = 0; i < V; i++) {
        key[i] = INT_MAX;
        parent[i] = -1;
        pos[i] = i;
        heap[i].vertex = i;
        heap[i].key = INT_MAX;
    }
    // 从顶点 0 开始构建最小生成树
    key[0] = 0;
    heap[0].key = 0;
    int heapSize = V;
    while (heapSize > 0) {
        // 提取最小 key 值的顶点
        QueueElement minElement = extractMin(heap, pos, &heapSize);
        int u = minElement.vertex;
        // 遍历所有相邻顶点
        for (int v = 0; v < V; v++) {
            if (graph[u][v] && isInHeap(pos, v, heapSize) && graph[u][v] < key[v]) {
                key[v] = graph[u][v];
                parent[v] = u;
                decreaseKey(heap, pos, heapSize, v, key[v]);
            }
        }
    }
    // 打印最小生成树
    printMST(parent, graph, V);
    // 释放动态分配的内存
    free(parent);
    free(key);
    free(pos);
    free(heap);
}
int main() {
    int V;
    printf("请输入图的顶点数量: ");
    scanf("%d", &V);
    // 动态分配邻接矩阵的内存
    int **graph = (int **)malloc(V * sizeof(int *));
    for (int i = 0; i < V; i++) {
        graph[i] = (int *)malloc(V * sizeof(int));
    }
    printf("请输入图的邻接矩阵（%d x %d）:\n", V, V);
    for (int i = 0; i < V; i++) {
        for (int j = 0; j < V; j++) {
            scanf("%d", &graph[i][j]);
        }
    }
    // 调用堆优化的 Prim 算法求解最小生成树
    primMST(graph, V);
    // 释放邻接矩阵的内存
    for (int i = 0; i < V; i++) {
        free(graph[i]);
    }
    free(graph);
    return 0;
}

8.[逆序数算法】编写一个函数 countInversions，用于计算整数数组中的逆序对数。逆序对是指满足条件 i < j 且 arr[i] > arr[j] 的数对 (i, j)。

#include <stdio.h>
#include <stdlib.h>
int merge(int arr[], int left, int mid, int right) {
    int n1 = mid - left + 1;
    int n2 = right - mid;
    int L[n1], R[n2];
    int i, j, k;
    int inversions = 0;
    for (i = 0; i < n1; i++)
        L[i] = arr[left + i];
    for (j = 0; j < n2; j++)
        R[j] = arr[mid + 1 + j];
    i = 0; 
    j = 0; 
    k = left; 
    while (i < n1 && j < n2) {
        if (L[i] <= R[j]) {
            arr[k] = L[i];
            i++;
        } else {
            arr[k] = R[j];
            j++;
            inversions += (n1 - i);
        }
        k++;
    }
    while (i < n1) {
        arr[k] = L[i];
        i++;
        k++;
    }
    while (j < n2) {
        arr[k] = R[j];
        j++;
        k++;
    }

    return inversions;
}
int mergeSort(int arr[], int left, int right) {
    int inversions = 0;
    if (left < right) {
        int mid = left + (right - left) / 2;
        inversions += mergeSort(arr, left, mid);
        inversions += mergeSort(arr, mid + 1, right);
        inversions += merge(arr, left, mid, right);
    }
    return inversions;
}
int countInversions(int arr[], int n) {
    return mergeSort(arr, 0, n - 1);
}

int main() {
    char input[1000];
    int arr[1000];
    int n = 0;
    fgets(input, sizeof(input), stdin);
    int i = 1;
    while (input[i] != '\0') {
        if (input[i] == ']') {
            break;
        }
        if (input[i] != ' ' && input[i] != ',') {
            int num = 0;
            int sign = 1;
            if (input[i] == '-') {
                sign = -1;
                i++;
            }
            while (input[i] >= '0' && input[i] <= '9') {
                num = num * 10 + (input[i] - '0');
                i++;
            }
            arr[n++] = sign * num;
        } else {
            i++;
        }
    }

    int inversions = countInversions(arr, n);
    printf(" %d\n", inversions);

    return 0;
}

9.实现 Median of Medians 算法，用于在无序数组中找出第 k 小的元素。

#include <stdio.h>
#include <stdlib.h>
// 交换函数
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}
// 插入排序（用于小数组排序和验证用）
void insertionSort(int arr[], int left, int right) {
    for (int i = left + 1; i <= right; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= left && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}
// 获取一组的中位数
int getMedian(int arr[], int left, int right) {
    insertionSort(arr, left, right);
    return arr[(left + right) / 2];
}
// 分区操作
int partition(int arr[], int left, int right, int pivot) {
    int i;
    for (i = left; i <= right; i++) {
        if (arr[i] == pivot) break;
    }
    swap(&arr[i], &arr[right]);

    int storeIndex = left;
    for (i = left; i < right; i++) {
        if (arr[i] < pivot) {
            swap(&arr[i], &arr[storeIndex]);
            storeIndex++;
        }
    }
    swap(&arr[storeIndex], &arr[right]);
    return storeIndex;
}
// 主算法：Median of Medians
int selectKth(int arr[], int left, int right, int k) {
    int n = right - left + 1;
    if (n <= 5) {
        insertionSort(arr, left, right);
        return arr[left + k - 1];
    }
    int medianCount = (n + 4) / 5;
    int *medians = (int *)malloc(medianCount * sizeof(int));
    for (int i = 0; i < medianCount; i++) {
        int subLeft = left + i * 5;
        int subRight = subLeft + 4;
        if (subRight > right) subRight = right;
        medians[i] = getMedian(arr, subLeft, subRight);
    }
    int medOfMed = selectKth(medians, 0, medianCount - 1, (medianCount + 1) / 2);
    free(medians);
    int pivotIndex = partition(arr, left, right, medOfMed);
    int rank = pivotIndex - left + 1;
    if (k == rank)
        return arr[pivotIndex];
    else if (k < rank)
        return selectKth(arr, left, pivotIndex - 1, k);
    else
        return selectKth(arr, pivotIndex + 1, right, k - rank);
}
// 主函数
int main() {
    int n, k;
    printf("请输入数组长度 n：");
    scanf("%d", &n);
    if (n <= 0) {
        printf("错误：数组长度必须为正数！\n");
        return 1;
    }
    int *arr = (int *)malloc(n * sizeof(int));
    int *arrCopy = (int *)malloc(n * sizeof(int));
    printf("请输入 %d 个整数：\n", n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &arr[i]);
        arrCopy[i] = arr[i]; // 复制一份用于验证
    }
    printf("请输入要查找的第 k 小元素 (1 ~ %d)：", n);
    scanf("%d", &k);
    if (k < 1 || k > n) {
        printf("错误：k 值不合法！\n");
        free(arr);
        free(arrCopy);
        return 1;
    }
    int result = selectKth(arr, 0, n - 1, k);
    printf("第 %d 小的元素是：%d\n", k, result);
    // 验证部分
    insertionSort(arrCopy, 0, n - 1);
    int expected = arrCopy[k - 1];
    if (result == expected) {
        printf("验证结果：正确\n");
    } else {
        printf("验证结果：错误 （应为 %d）\n", expected);
    }
    free(arr);
    free(arrCopy);
    return 0;
}

10.掌握动态规划求解0-1背包问题的基本思想与实现步骤。

# 1.给定若干个物品，每个物品有重量和价值，背包容量为一定的正整数。

# 2.实现一个动态规划算法，求解在给定容量下，能够装入背包的最大总价值。

# 3.输出最终最大价值，以及用于构造该最优值的物品组合（可选）。

# 4.显示动态规划中构建的二维数组 dp[i][j] 的过程（物品编号 i、容量 j）。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 打印二维数组 dp
void printDP(const vector< vector<int> >& dp) {
    for (int i = 0; i < dp.size(); i++) {
        for (int j = 0; j < dp[i].size(); j++) {
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}
// 回溯找出选择的物品
vector<int> findSelectedItems(const vector< vector<int> >& dp, const vector<int>& weights, const vector<int>& values, int n, int capacity) {
    vector<int> selectedItems;
    int i = n, j = capacity;
    while (i > 0 && j > 0) {
        if (dp[i][j] != dp[i - 1][j]) {
            selectedItems.push_back(i);
            j -= weights[i - 1];
        }
        i--;
    }
    vector<int> reversedItems;
    for (int k = selectedItems.size() - 1; k >= 0; k--) {
        reversedItems.push_back(selectedItems[k]);
    }
    return reversedItems;
}
int main() {
    int n; // 物品数量
    int capacity; // 背包容量
    cout << "请输入物品数量: ";
    cin >> n;
    cout << "请输入背包容量: ";
    cin >> capacity;
    vector<int> weights(n);
    vector<int> values(n);
    cout << "请依次输入每个物品的 编号 重量 价值（格式：编号 重量 价值）：" << endl;
    for (int i = 0; i < n; i++) {
        int id;
        cout << "物品 " << i + 1 << ": ";
        cin >> id >> weights[i] >> values[i];
    }
    // 初始化二维数组 dp
    vector< vector<int> > dp(n + 1);
    for (int i = 0; i <= n; i++) {
        dp[i].resize(capacity + 1, 0);
    }
    // 动态规划过程
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= capacity; j++) {
            if (j < weights[i - 1]) {
                dp[i][j] = dp[i - 1][j];
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]);
            }
        }
        // 输出每一步的二维数组变化情况
        cout << "Step " << i << ":" << endl;
        printDP(dp);
    }
    // 输出最大价值
    int maxValue = dp[n][capacity];
    cout << "最大价值: " << maxValue << endl;
    // 找出选择的物品
    vector<int> selectedItems = findSelectedItems(dp, weights, values, n, capacity);
    cout << "选择的物品编号: ";
    for (int i = 0; i < selectedItems.size(); i++) {
        cout << selectedItems[i] << " ";
    }
     cout << endl;
    return 0;
}

11.编写程序，使用回溯法输出给定整数序列的所有排列，例如输入{1，2，3}

#include <iostream>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std;
// 回溯函数生成全排列
void backtrack(vector<int>& nums, vector<int>& path, vector<bool>& used) {
    if (path.size() == nums.size()) {
        for (int i = 0; i < path.size(); ++i) {
            cout << path[i] << " ";
        }
        cout << endl;
        return;
    }
    for (int i = 0; i < nums.size(); ++i) {
        if (!used[i]) {
            used[i] = true;
            path.push_back(nums[i]);
            backtrack(nums, path, used);
            path.pop_back();
            used[i] = false;
        }
    }
}
int main() {
    string input;
    getline(cin, input);
    istringstream iss(input);
    vector<int> nums;
    int num;
    while (iss >> num) {
        nums.push_back(num);
    }
    if (nums.empty()) {
        cout << "输入不能为空！" << endl;
        return 1;
    }
    vector<int> path;
    vector<bool> used(nums.size(), false);
    backtrack(nums, path, used);
    return 0;
}

12、分支限界发求解0-1背包问题//给定一组物品，每个物品有重量wi和价值vi，以及一个容量为C的背包。要求选择物品的子集，使得总重量不超过背包容量，且总价值最大。每个物品只能选或不选（0-1属性）。

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
// 物品结构体
struct Item {
    int index;
    int weight;
    int value;
    double ratio;
    Item(int idx, int w, int v) : index(idx), weight(w), value(v) {
        ratio = (double)v / w;
    }
};
// 分支限界树节点结构体
struct Node {
    int level;
    int value;
    int weight;
    double bound;
    vector<int> path;
    bool operator<(const Node& other) const {
        return bound < other.bound;
    }
};
// 上界计算函数
double computeBound(Node u, int n, int W, const vector<Item>& items) {
    if (u.weight >= W) return 0;
    double bound = u.value;
    int totalWeight = u.weight;
    for (int i = u.level; i < n; ++i) {
        if (totalWeight + items[i].weight <= W) {
            totalWeight += items[i].weight;
            bound += items[i].value;
        } else {
            int remain = W - totalWeight;
            bound += remain * items[i].ratio;
            break;
        }
    }
    return bound;
}
// 主算法
int knapsackBranchBound(int W, vector<Item>& items, vector<int>& bestPath) {
    sort(items.begin(), items.end(), [](const Item& a, const Item& b) {
        return a.ratio > b.ratio;
    });
    priority_queue<Node> pq;
    int maxValue = 0;
    Node root = {0, 0, 0, 0.0, {}};
    root.bound = computeBound(root, items.size(), W, items);
    pq.push(root);
    while (!pq.empty()) {
        Node current = pq.top(); pq.pop();
        if (current.bound <= maxValue || current.level == items.size())
            continue;
        // 包含当前物品
        Node include = current;
        Item item = items[current.level];
        include.level++;
        include.weight += item.weight;
        include.value += item.value;
        include.path.push_back(item.index);
        include.bound = computeBound(include, items.size(), W, items);
        if (include.weight <= W && include.value > maxValue) {
            maxValue = include.value;
            bestPath = include.path;
        }
        if (include.bound > maxValue)
            pq.push(include);
        // 不包含当前物品
        Node exclude = current;
        exclude.level++;
        exclude.bound = computeBound(exclude, items.size(), W, items);
        if (exclude.bound > maxValue)
            pq.push(exclude);
    }
    return maxValue;
}
int main() {
    int n, W;
    cout << "请输入物品数量：";
    cin >> n;
    cout << "请输入背包容量：";
    cin >> W;
    vector<int> weights(n), values(n);
    cout << "请输入所有物品的重量：" << endl;
    for (int i = 0; i < n; ++i) {
        cin >> weights[i];
    }
    cout << "请输入所有物品的价值：" << endl;
    for (int i = 0; i < n; ++i) {
        cin >> values[i];
    }
    vector<Item> items;
    for (int i = 0; i < n; ++i) {
        items.emplace_back(i + 1, weights[i], values[i]);
    }
    vector<int> selectedItems;
    int maxValue = knapsackBranchBound(W, items, selectedItems);
    cout << "\n最大价值：" << maxValue << endl;
    cout << "选择物品：" << endl;
    for (int idx : selectedItems) {
        cout << "  物品" << idx << "（重量" << weights[idx - 1]
             << "，价值" << values[idx - 1] << "）" << endl;
    }
    return 0;
}

wxkoe
关注
汉字--拼音--网页汉字转拼音--包教包会
liuhao9999的博客
09-07 1万+
"疮": "chuāng","窗": "chuāng","幢": "zhuàng","床": "chuáng","闯": "chuǎng","创": "chuàng","霜": "shuāng","双": "shuāng","桩": "zhuāng","庄": "zhuāng","装": "zhuāng","妆": "zhuāng","撞": "zhuàng","壮": "zhuàng","状": "zhuàng","昌": "chāng","猖": "chāng","场": "chǎng",
Unity中的TextMeshPro
L的博客
11-05 7488
TextMeshPro使用了不同的技术来渲染文字，叫做Signed Distance Field(SDF)。和UGUI类似，这个技术同样需要将字符放到一个图集中，但是不使用像素来代表字符的形状，而使用SDF技术来生成字符的形状。使用这种技术字符在渲染时不会因为缩放而造成字符模糊的情况，总是能够准确的渲染字符的边缘 一：TextMeshPro无法识别中文字符 TextMeshPro无法识别中文字...
方正兰亭黑_GBK-v1.20
能力创造快乐！
04-26 2664
�!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¢£¤¥§¨°±·×àáèéêìíòó÷ùúüýþÿīń
个人使用整理的部分测试数据整理-输入类2022
iiill的博客
01-19 5482
个人使用的部分测试数据整理汇总
方正兰亭纤黑简体字集-v1.10
能力创造快乐！
04-26 2569
�!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~¢£¤¥§¨°±·×àáèéêìíòó÷ùúüýþÿīń
主反忠作战笔记
enthan809882的博客
01-30 818
鲁智深 技能： 底力、狂禅 单挑前10、主要是底力太强，太难杀死了。 狂禅已废，作为主公时不再加一点血，但还是很强。 克制鲁智深 要点就是没有把握不要伤他血，可以卸装备等，有把握再出手。 一般人打不过他的，要克制他就是一波打死 。 例如：勾践，赵飞燕等 赵飞燕 技能：玉步，轻影 看人品的英雄，运气好一波n张牌，瞬间秒人。 轻影没闪的时候黑牌当做闪，防御力也不错。 克制赵飞燕 韩信 技能： 兵仙，攻心 兵仙神技，多摸一张牌 。 攻心拿没用的牌，让对面猜，猜错掉血，猜对牌给对面也没用。 刘邦 技能：驾人 技能是
乱斗西游背景介绍
九天虚空的博客
05-26 1510
乱斗西游 背景介绍         南宋年间，盛世大唐已如过往云烟，揭开尘埃下的历史，才发觉原来唐僧师徒为广布佛法西去求取大乘真经已是500年前的旧事，不知那些尘封的经书是否还有人翻阅，那条西行的路途可还有人记得，路途上那些取经的人，拦路的妖，如今又在何方。         而今现世动荡风雨飘摇，四处兵荒马乱生灵涂炭，百姓处在水深火热之中哀嚎遍野，神佛观世间疾苦，为普度众生得安乐，找到五百年一现...
三十六计之敌战计
懒人的技术笔记
11-16 1万+
敌战计是当敌我处于势均力敌态势时使用的计谋。 此篇共有六计，它们是无中生有、暗渡陈仓、隔岸观火、笑里藏刀、李代桃僵、顺手牵羊。 第七计 无中生有     诳也，非诳也，实其所诳也①。少阴、太阴、太阳②。     ①诳也，非诳也，实其所诳也：诳，欺诈、诳骗。实，实在，真实，此处作意 动词。句意为：运用假象欺骗对方，但并非一假到底，而是让对方把受骗的假象当 成 真象。     ②少阴，太
用JS写一个电影《黑客帝国》显示屏黑底绿字雨风格的唐诗欣赏器
KISS
04-05 1万+
效果图 放码过来 <!DOCTYPE HTML> <html> <head> <meta http-equiv="Content-Type" content="text/html;charset=utf-8"/> <title>Black Screen And Green Letter</title> <style type="text/css"> table{ /*font-size:500%;
经济学十大原理
howard2005的专栏
07-19 4154
经济学是一种视角，是一个决策者——不管是政府官员、企业家或普罗大众——在需要做决策时，总是在所能有的选择方案中，选出其当时所认为的最好方案所凭借的观察和分析真实世界现象的视角。..................
深度学习&PyTorch 之 RNN-中文多分类
Andy_shenzl的博客
02-28 3273
关于RNN的理论部分我们已经在前面介绍过，所以这里直接上代码 数据是csv格式，只有两列，第一列是标签（但是为中文），第二列是text，文本内容。 当然这里也可以加入停用词我们需要构建和处理文本数据的词汇表。词汇表是自然语言处理中的一个基本概念，它将文本中的单词映射到唯一的整数ID上。这样，文本数据就可以被转换为机器可以理解的数字格式。 创建好的词汇表如下我们之前看到标签是，等文本，需要转换成数值标签 代码中给出了详细的注释，所以就不过多的解释。查看下数据 模型结构 3、 开始训练 完整代码
[MSSQL]SQL简繁转换函数
热门推荐
德仔
02-16 10万+
  --全部的简繁对照 declare @jall nvarchar(4000),@fall nvarchar(4000) select @jall=N'啊阿埃挨哎唉哀皑癌蔼矮艾碍爱隘鞍氨安俺按暗岸胺案肮昂盎凹敖熬翱袄傲奥懊澳芭捌扒叭吧笆八疤巴拔跋靶把耙坝霸罢爸白柏百摆佰败拜稗斑班搬扳般颁板版扮拌伴瓣半办绊邦帮梆榜膀绑棒磅蚌镑傍谤苞胞包褒剥薄雹保堡饱宝抱报暴豹鲍爆杯碑悲卑北辈背贝钡倍狈备惫焙被...
【WordCloud】将周董的歌用词云可视化
weixin_43826681的博客
12-21 1万+
目录一、准备数据二、代码三、运行效果图四、遇到的问题和解决方法五、歌词 一、准备数据 来自他人的GitHub：地址 只需要用 NLP_tools/NLP/tf_char_rnn/周杰伦歌词大全_cleaned.txt 文件就好了 二、代码 # coding=gbk import jieba from wordcloud import WordCloud import matplotlib.pyplot as plt from collections import Counter text = lis
常用汉字库整理集
bug_love的博客
11-06 722
【代码】常用汉字库整理集。
LeetCode热题100--70. 爬楼梯--简单
最新发布
2301_80071187的博客
12-20 211
这道题考察爬楼梯问题，每次可以爬1或2个台阶，求爬到n阶的不同方法数。采用动态规划解法，初始化dp数组，dp[0]=1，dp[1]=1。对于i≥2，dp[i]=dp[i-1]+dp[i-2]，即当前台阶的方法数等于前两个台阶方法数之和。最终返回dp[n]即为结果。该解法时间复杂度O(n)，空间复杂度O(n)。
智驾空间智能、物理智能、世界模型相关的最新论文和开源算法链接
Bonaventure的博客
12-16 1036
这些资源涵盖了2025年自动驾驶领域的前沿研究，从空间推理到物理建模和世界模拟，提供了丰富的开源工具和理论框架。建议用户通过链接深入探索论文和代码，以应用于实际项目或进一步研究。如果您需要更详细的解读或特定应用建议，请随时补充信息！
【算法笔记】AC自动机
u012559967的专栏
12-19 721
AC自动机: AC自动机是一种高效的多模式字符串匹配算法，它巧妙地将 Trie树的字典结构与 KMP算法的失配指针思想相结合，能同时在一段文本中查找多个模式串的所有出现位置，广泛应用于敏感词过滤、生物信息学序列分析等领域。在字符串匹配领域，我们会遇到两类问题：单模式匹配：给定一个文本字符串和一个模式字符串，判断模式字符串是否出现在文本字符串中。《【算法笔记】KMP算法》多模式匹配：给定一个文本字符串和多个模式字符串，判断所有模式字符串是否出现在文本字符串中。解决方案：AC自动机算法。
(leetcode) 力扣100 15轮转数组（环状替代）
qq_62235017的博客
12-18 989
我们利用这个过程，首先计算需要多少个从起点走回起点的圈数（count，为数组长度与步数的最大公约数，具体推推导后面会给），然后再遍历每一圈，通过创建一个临时变量（current,next，类似于指针的作用），来存储需要移动的变量将其移动到下一个位置，而下一个位置变为信的需移动变量，直到走完当前圈数。我们可以把数组想象一个圆圈，如果我们每次固定步数前进，肯定会在有限圈数回到出发点，这个过程中，有可能会遍历完数组所有数，有可能遍历有限数。这句话的意思是：在这个游戏中，你启动一次任务，只能覆盖到。
Leetcode 79 最佳观光组合
im_AMBER的博客
12-17 580
每个元素只遍历一次只用了两个变量O(n)O(1)公式拆分是核心：将原得分公式拆分为，把双变量问题转化为单变量的遍历问题。贪心维护最优值：遍历j时，用best维护之前所有i < j中的最大值，这样每一步只需要 O (1) 计算，整体时间复杂度是 O (n)。遍历顺序：因为要求i < j，所以从j=1开始遍历，先计算当前j的得分，再更新best（避免 j 自己和自己配对）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值