【CSP考点总结】（3）

最新推荐文章于 2024-05-13 21:32:22 发布
最新推荐文章于 2024-05-13 21:32:22 发布
阅读量247 收藏
点赞数 5
分类专栏： CSP备考 文章标签： 图论 深度优先 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fzy2003/article/details/137225824
版权

十一、二维矩阵的Z字扫描

void zScan(vector<vector<int>>& M, vector<int>& m) {
    int size = 8; // 矩阵大小为8x8
    vector<int> result;
    int i = 0, j = 0, mi = 0;
    bool up = true; // 用于标识当前移动方向，初始为向上

    for (int k = 0; k < size * size; ++k) {
        if (mi < m.size())
        {
            M[i][j] = m[mi];
            mi++;
        }
        else M[i][j] = 0;

        if (up) { // 如果当前方向是向上
            if (j == size - 1) { // 如果触及右边界
                ++i; // 向下移动
                up = false; // 改变方向
            }
            else if (i == 0) { // 如果触及上边界
                ++j; // 向右移动
                up = false; // 改变方向
            }
            else { // 否则，继续向上和向右移动
                --i;
                ++j;
            }
        }
        else { // 如果当前方向是向下
            if (i == size - 1) { // 如果触及底边界
                ++j; // 向右移动
                up = true; // 改变方向
            }
            else if (j == 0) { // 如果触及左边界
                ++i; // 向下移动
                up = true; // 改变方向
            }
            else { // 否则，继续向下和向左移动
                ++i;
                --j;
            }
        }
    }
}

十二、快速排序

void quickSort(int arr[], int left, int right) {
    if (left < right) {
        int pivot = partition(arr, left, right); // 执行分区操作，找到基准元素的正确位置
        quickSort(arr, left, pivot - 1);  // 递归对基准元素左侧的元素进行快速排序
        quickSort(arr, pivot + 1, right); // 递归对基准元素右侧的元素进行快速排序
    }
}

int partition(int arr[], int left, int right) { // 分区函数
    int pivot = arr[right];  // 选择最右侧的元素作为基准元素
    int i = left - 1;  // i指针用于跟踪比基准小的元素的最后位置
    for (int j = left; j < right; j++) {
        // 如果当前元素小于或等于基准元素
        if (arr[j] <= pivot) {
            i++;    // 移动i指针
            swap(arr[i], arr[j]); // 交换元素，将较小的元素移至左侧
        }
    }
    swap(arr[i + 1], arr[right]); // 将基准元素移至正确的位置
    return i + 1; // 返回基准元素的位置
}

int main() {
    int arr[] = {10, 7, 8, 9, 1, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    quickSort(arr, 0, n - 1); // 对数组进行快速排序
    cout << "排序后的数组: ";
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
    return 0;
}

十三、DFS/BFS

struct TreeNode {
    int value;           // 节点存储的值
    TreeNode *left;      // 指向左子节点的指针
    TreeNode *right;     // 指向右子节点的指针
    TreeNode(int val) : value(val), left(nullptr), right(nullptr) {}
};

void depthFirstSearch(TreeNode* node) { // 深度优先搜索函数
    if (node == nullptr) return; // 如果节点为空，则返回
    cout << node->value << " "; // 处理当前节点，例如打印节点值
    depthFirstSearch(node->left); // 递归搜索左子树
    depthFirstSearch(node->right); // 递归搜索右子树
}

void breadthFirstSearch(TreeNode* root) { // 广度优先搜索函数
    if (root == nullptr) return; // 如果树为空，则直接返回
    queue<TreeNode*> q; // 定义一个队列，用于存储每一层的节点
    q.push(root); // 将根节点加入队列
    while (!q.empty()) { // 只要队列不为空，就继续执行
        TreeNode* node = q.front(); // 获取队列前端的节点
        q.pop(); // 移除已经访问的节点
        cout << node->value << " "; // 处理当前节点，这里是打印节点的值
        // 如果左子节点存在，加入队列
        if (node->left != nullptr) {
            q.push(node->left);
        }
        // 如果右子节点存在，加入队列
        if (node->right != nullptr) {
            q.push(node->right);
        }
    }
}

int main() {
    // 构建树
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->left->left = new TreeNode(4);
    root->left->right = new TreeNode(5);

    cout << "深度优先搜索结果: ";
    depthFirstSearch(root);
    cout << "广度优先搜索结果: ";
    breadthFirstSearch(root);

    // 清理分配的内存
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right;
    delete root;
    return 0;
}


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

class Graph {
public:
    int V; // 图的顶点数
    list<int> *adj; // 邻接表
    Graph(int V); // 构造函数
    void addEdge(int v, int w); // 添加边
    void DFS(int v); // 深度优先搜索
    void BFS(int v); // 广度优先搜索
private:
    void DFSUtil(int v, vector<bool> &visited); // 用于DFS的辅助函数
};

Graph::Graph(int V) {
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int v, int w) {
    adj[v].push_back(w); // 添加v到w的边
}

void Graph::DFSUtil(int v, vector<bool> &visited) {
    visited[v] = true; // 标记当前节点为已访问
    cout << v << " ";
    // 递归访问所有未访问的邻居
    for (auto i = adj[v].begin(); i != adj[v].end(); ++i) {
        if (!visited[*i]) {
            DFSUtil(*i, visited);
        }
    }
}

void Graph::DFS(int v) {
    vector<bool> visited(V, false); // 初始化所有顶点为未访问
    DFSUtil(v, visited); // 从v开始DFS
}

void Graph::BFS(int v) {
    vector<bool> visited(V, false); // 初始化所有顶点为未访问
    queue<int> queue;
    visited[v] = true; // 标记起始节点为已访问
    queue.push(v); // 将起始节点加入队列
    while (!queue.empty()) {
        // 从队列中弹出一个顶点进行访问
        v = queue.front();
        cout << v << " ";
        queue.pop();
        // 获取所有未访问的邻居，标记为已访问，然后加入队列
        for (auto i = adj[v].begin(); i != adj[v].end(); ++i) {
            if (!visited[*i]) {
                visited[*i] = true;
                queue.push(*i);
            }
        }
    }
}

int main() {
    // 创建一个包含4个顶点的图
    Graph g(4);
    g.addEdge(0, 1);
    g.addEdge(0, 2);
    g.addEdge(1, 2);
    g.addEdge(2, 0);
    g.addEdge(2, 3);
    g.addEdge(3, 3);
    cout << "深度优先搜索（从顶点2开始）:" << endl;
    g.DFS(2);
    cout << "\n广度优先搜索（从顶点2开始）:" << endl;
    g.BFS(2);
    return 0;
}

十四、设置输出宽度以及小数点后几位

#include <iostream>
#include <iomanip> // 包含setw和setprecision
using namespace std;
int main() {
    double pi = 3.14159265;
    int number = 123;
    // 设置宽度为10，并填充空格
    cout << setw(10) << number << endl;
    // 设置宽度为10，填充空格，以及设置小数点后显示3位
    cout << setw(10) << setprecision(3) << pi << endl;
    // 设置宽度为10，填充空格，小数点后显示5位，并固定小数点表示法
    cout << setw(10) << setprecision(5) << fixed << pi << endl;
    // 如果想要后续的输出也保持这种格式设置，可以不重置宽度和精度
    // 重置精度为默认值，显示所有小数位
    cout << setprecision(0) << scientific; // 重置为科学计数法表示
    cout << pi << endl;
    return 0;
}

十五、哈希函数

#include <iostream>
#include <list>
using namespace std;
// 哈希表大小
#define HASH_TABLE_SIZE 10
class HashTable {
private:
    list<int> table[HASH_TABLE_SIZE];
    // 哈希函数
    int hashFunction(int x) {
        return x % HASH_TABLE_SIZE;
    }
public:
    // 插入
    void insertItem(int key) {
        int index = hashFunction(key);
        table[index].push_back(key);
    }
    // 删除
    void removeItem(int key) {
        int index = hashFunction(key);
        table[index].remove(key);
    }
    // 显示哈希表
    void displayHash() {
        for (int i = 0; i < HASH_TABLE_SIZE; i++) {
            cout << i;
            for (auto x : table[i])
              cout << " --> " << x;
            cout << endl;
        }
    }
};

int main() {
    HashTable ht;
    // 插入键到哈希表
    ht.insertItem(10);
    ht.insertItem(20);
    ht.insertItem(15);
    ht.insertItem(25);

    ht.removeItem(15);
    ht.displayHash();
    return 0;
}

十六、Dijkstra

Dijkstra算法是一种用于在图中找到从单一源点到所有其他节点的最短路径的算法

#include <iostream>
#include <vector>
#include <limits>
using namespace std;
// 定义无穷大为INT_MAX
const int INF = numeric_limits<int>::max();
// 找到最短路径树集合中距离最小的顶点
int minDistance(const vector<int>& dist, const vector<bool>& sptSet, int V) {
    int min = INF, min_index; 
    for (int v = 0; v < V; v++)
        if (!sptSet[v] && dist[v] <= min)
            min = dist[v], min_index = v;
    
    return min_index;
}

// 打印Dijkstra算法的结果
void printSolution(const vector<int>& dist, int V) {
    cout << "顶点 \t 距离源点的距离\n";
    for (int i = 0; i < V; i++)
        cout << i << " \t\t" << dist[i] << "\n";
}

// 实现Dijkstra算法
void dijkstra(const vector<vector<int>>& graph, int src, int V) {
    vector<int> dist(V, INF); // 距离数组，dist[i]保存从源到顶点i的最短距离
    vector<bool> sptSet(V, false); // sptSet[i]为true，如果顶点i已在最短路径树中，或距离为最短
    dist[src] = 0; // 源点到自身的距离总是0
    for (int count = 0; count < V - 1; count++) {
        int u = minDistance(dist, sptSet, V);   
        sptSet[u] = true;       
        for (int v = 0; v < V; v++)
            if (!sptSet[v] && graph[u][v] && dist[u] != INF && dist[u] + graph[u][v] < dist[v])
                dist[v] = dist[u] + graph[u][v];
    }
    printSolution(dist, V);
}

int main() {
    /* 创建图的示例 */
    int V = 9;
    vector<vector<int>> graph = {
        {0, 4, 0, 0, 0, 0, 0, 8, 0},
        {4, 0, 8, 0, 0, 0, 0, 11, 0},
        {0, 8, 0, 7, 0, 4, 0, 0, 2},
        {0, 0, 7, 0, 9, 14, 0, 0, 0},
        {0, 0, 0, 9, 0, 10, 0, 0, 0},
        {0, 0, 4, 14, 10, 0, 2, 0, 0},
        {0, 0, 0, 0, 0, 2, 0, 1, 6},
        {8, 11, 0, 0, 0, 0, 1, 0, 7},
        {0, 0, 2, 0, 0, 0, 6, 7, 0}
    };
    dijkstra(graph, 0, V); // 以顶点0为源点执行Dijkstra算法
    return 0;
}

十七、使用stringstream分割单词

string input;
getline(cin, input); // 获取整行输入
vector<string> words;
string word;
stringstream ss(input);
while (ss >> word) {
    words.push_back(word);
}
LOST P
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CSP-2020J3答案
10-04
https://blog.csdn.net/m0_45682806/article/details/108909553，试题
CSP历年考点分析
Thinking_Liang的博客
11-19 1497
CSP历年考点分析
2020csp参赛总结
keyixi的博客
11-22 315
2020csp参赛总结 （本人第一次csp比赛，只参加了入门组） ——这次比赛表现还算理想 (入门315） ，但也有做得好和不好的地方， 过程与得失还是值得我去记录与总结的。 ——人们都说结果不重要，过程最重要，而我这次比赛的过程也算曲折。在比赛的前一天晚上，我们一家提前来到广州住了一晚，第二天很早就来到考点。我进入考场，监考员说完注意事项，比赛开始了。比赛开始后，我立刻建好文件和题目子文件，建好后我简单地看一遍全部题目，便开始做第一题“优秀的差分”。第一题当然很简单，我花了大概15分钟码完代码并检查、修
CSP2021总结
Noirr_的博客
10-25 584
CSP2021总结 DayDayDay：−2-2−2 复习了之前考试的错题，总结了做法和经验 看了很多其他人的游记，有了心理准备 DayDayDay：−1-1−1 复习了一大堆板子：tarjantarjantarjan、kmpkmpkmp、逆序对、回文串（蒙对了）、线段树、树状数组、树剖、主席树……… 打了前几年cspcspcsp的题练手，感觉不是很难，T1、T2至少能做（大模拟除外），T3能骗分，T4看运气 回家看了很多奇技淫巧的博客，补充了一定知识 DayDayDay：000 学校离考点不远，但是就是坐
CSP-J/S初赛考点总结
热门推荐
ShineEternal的笔记小屋
10-10 1万+
大家好呀，本博文是为了要冲pj1=的奆老们写的，很多奆老OI水平很高，但是普及组初赛会考一些其他的知识，而且这些知识零零散散的，让我们来整理一下。 这篇博文只是列举了知识点，如果要练习的话，按照下面的顺序： 从2019年CSPJ开始倒序刷题 如果嫌题不够，可以去刷信息学奥赛一本通–初赛篇 初赛不计入最后的算分和评分之内，所以初赛包过就行，最重要的还是复赛刷题。 如果完全背下来了这篇文章，至少初赛通过是没问题的（狗头 计算机常识 IT : Information Technology 信息技术 代别 年代 逻
CSP考点分布及如何取得好成绩.pdf
09-02
CSP考点分布及如何取得好成绩.pdf
CSP2022总结&题解&实现代码
01-25
CSP2022总结&题解&实现代码
csp-j初赛总结-各种题型
05-09
csp-j初赛总结-各种题型
CCF-CSP认证历年真题
03-05
这是CSP考试认证的历年真题总结，方便查阅与复习。大家复习时可以拿来做参考。
综合模型及应用(图论学习总结部分内容)
smile__everydays的博客
05-13 1176
由于图论学习总结内容过多，全放在一篇博客过于冗长现进行拆分，本文是图论学习总结(For XCPC)的综合模型及应用部分
数据结构之图——探索图论的奥秘
纪大侠博客
05-11 937
以上简单介绍了，图论知识。对于图论中用的比较多最短路和k短路用Java实现了。实际图论是比较难的问题，这边只是做了简单的介绍，抛砖引玉。
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5082
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
Java 7大排序
m0_74270127的博客
05-10 812
插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序
【算法】NOIP2003神经网络
最新发布
littlegengjie的博客
05-13 580
图中，X1—X3是信息输入渠道，Y1－Y2是信息输出渠道，C1表示神经元目前的状态，Ui是阈值，可视为神经元的一个内在参数。然后根据拓扑排序一次遍历该图的所有点（例如便利到点1，会遍历所有以点1位直接前驱的点），遍历点1之后，3、4、5的状态均为1，遍历点2之后3、4、5均为2，将所有输出点的状态减去阈值，就为最终状态。现在，给定一个神经网络，及当前输入层神经元的状态（Ci），要求你的程序运算出最后网络输出层的状态。再下面P行，每行由两个整数i，j及一个整数Wij，表示连接神经元i、j的边权值为Wij。
1080：余数相同问题
如果没有特别说明，c++都是基于GCC-4.9.2运行的
05-11 374
【代码】：1080：余数相同问题
找第二大的数（分治法）
2201_75525567的博客
05-11 299
这段代码通过递归的方式，将数组分为两半，并分别找出左半部分和右半部分的两个最大数，然后比较这四个数的大小，得到第二大的数。这段代码是用来找出数组中第二大的数的。
力扣阶段练习(1).消失的数字
2301_79475128的博客
05-11 838
恰好。这便是使用异或寻找缺失数的思路。
2021csp初赛考点
09-04
2021年CSP初赛考点主要涵盖了以下几个方面。 首先，算法与数据结构是CSP考试的基本要求和重点考点之一。考生需要熟悉并掌握各类基本算法，如排序、查找、图算法等，并能够灵活运用不同的数据结构，如数组、链表、栈...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值