问题 D: 沙漏图形 tri2str [1*+] codeup

最新推荐文章于 2020-05-07 17:00:08 发布

原创

最新推荐文章于 2020-05-07 17:00:08 发布 · 439 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#codeup #c #输出图型

该博客介绍了如何使用C语言编程，根据输入的数字n生成一个正倒n层的星号沙漏图形。图形首行顶格，星号间有一个空格，示例给出了输入和输出的效果。

问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例

输入样例：

输出样例;

* * *
 * * 
  *
 * * 
* * *

参考代码：

#include<stdio.h>
int main(){
   
   
	int n;
	while(scanf("%d",&n) != EOF){
   
   
		int k = 2*n - 1;//一行最多的元素数
		int maxrow;	//一行包含多少个元素
		int jg1

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

Inniss_

关注关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

算法笔记入门（算法模拟图像）——问题 D: 沙漏图形 tri2str [1*+]

qq_52071659的博客

09-15

189

题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例： * * * * * * * * * * * 数据规模 1<= n <=50 思路分析：先输出倒三角形，再输出剩余部分即可。 #include <cstdio> #include <cmath> int main() { int n; scanf("%d",&n); int t=n; int m;

C语言 codeup2506 问题 D: 沙漏图形 tri2str [1*+] mw的解题思路与优化方案

Moon_White的博客

01-03

318

文章目录题目解题思路总体代码题目问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例数据规模 1<= n <=50 大概就是这个样子，具体看这→原题解题思路这道题其实就是在原有的对称沙漏的基础上右边要输出空格对齐。我原本想着是全部放在一个大循环里面实现，可是到中间后面几行时思考的太复杂。所以我选择上面到中间分为一部分一起输出，下面的分为另一部分进行输出。先讲上面到中间的这一部分。我先考虑的是最中间只输出一个 “ * ” 的这一部分

参与评论您还未登录，请先登录后发表或查看评论

代码练习系列：问题 D 沙漏图形 tri2str [1*+]

hanzy88的博客

11-02

787

题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例： * * * * * * * * * * * 数据规模 1<= n <=50 #include <stdio.h> #include <string.h> int main() { int num; ...

【算法笔记】问题 D: 沙漏图形

Echo.L 's blog

04-03

1539

问题描述：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例： * * * * * * * * * * * 解题思路：除了上下对称可以利用很简单的技巧，其他没什么好说的，直接上代码。代码： #include <stdio.h> int main() { int h; while (scanf("%d", &h...

《算法笔记》3.3小节——入门模拟->图形输出问题 D: 沙漏图形 tri2str [1*+]

Alihuhu

09-30

591

把握今天，才能拥有明天！按要求来就行。 #include<stdio.h> int main() { int n; while(scanf("%d",&n)!=EOF) { for(int i=n;i>1;i--) { int k; for(k=0;k<n...

算法笔记3.3 问题 D: 沙漏图形 tri2str [1*+]

Liberalspirit的博客

09-25

218

题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例： * * * * * * * * * * * 数据规模 1<= n <=50 #include<iostream> #include<string> #include<string.h> using namespa...

问题 D: 沙漏图形 tri2str [1*+]

Quebec_forever的博客

04-09

223

题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例： * * * * * * * * * * * 数据规模 1<= n <=50 #include <iostream> using namespace std; int main(void) { int index,num; cin&...

Kaldi单步完美运行AIShell v1 S5之三：三音tri1,tri2,tri3,tri4,tri5

我看故我听

01-13

3321

Kaldi单步完美运行AIShell v1 S5之三：三音tri1 2 3 4致谢Kaldi下AIShell v1详细输出之三：三音triphone第六部分：结果更新第七部分：三音Tri1训练、解码、校准第八部分：三音素tri2（delta+delta-deltas）第九部分：三音素tri3a[LDA+MLLT]第十部分：三音素tri4第11部分：三音素tri5（SAT）第12部分：nnet3 致...

算法笔记练习 3.3 图形输出问题 D: 沙漏图形 tri2str [1*+]

Gorgeoustray

05-07

518

算法笔记练习题解合集本题链接题目题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例： * * * * * * * * * * * 数据规模 1<= n <=50 思路先输出上半部分，再输出下半部分。代码 #include <cstdio> int main() { int n, i, ...

（算法练习）——沙漏图形 tri2str [1*+]

晴空

01-09

414

要求： http://codeup.cn/problem.php?cid=100000577&pid=3 说明：规律感觉是误打误撞找对的。。。图形题可能归根到底是总结每一行的变量与总行变量i之间的关系。。。代码： #include <stdio.h> int main(){ int n; while(scanf("%d",&n) != EOF){ for(i...

C 语言打印沙漏

05-07

PAT 测试题打印沙漏但是不知道为什么我的提交就是无效

Codeup墓地 Contest100000577 问题 D:沙漏图形

爱吃西瓜的博客

02-18

191

题目描述问题：输入n（1&lt;=n&lt;=50），输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例。输入样例： 3 输出样例： * * * * * * * * * * * 代码 #include&lt;cstdio&gt; int main(){ int N,blank,flag=1; scanf("%d",&amp;N);

C语言：打印沙漏

qq_40907345的博客

01-29

7551

本题要求你写个程序把给定的符号打印成沙漏的形状。例如给定17个“*”，要求按下列格式打印 ***** *** * *** ***** 所谓“沙漏形状”，是指每行输出奇数个符号；各行符号中心对齐；相邻两行符号数差2；符号数先从大到小顺序递减到1，再从小到大顺序递增；首尾符号数相等。给定任意N个符号，不一定能正好组成一个沙漏。要求打印出的沙漏能用掉尽可能多的符号。输入

沙漏图形

qq_35966478的博客

01-21

1598

问题 D: 沙漏图形 tri2str [1*+] 时间限制: 1 Sec 内存限制: 128 MB 提交: 341 解决: 240 [提交][状态][讨论版][命题人:外部导入] 题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例：数据规模 1<= n <=50 自己代码： #include...

2506 Problem D 沙漏图形 tri2str [1*+]

privilage的博客

04-14

312

题目描述问题：输入n，输出正倒n层星号三角形。首行顶格，星号间有一空格，效果见样例输入样例： 3 输出样例：* * * * * * * * * * *数据规模 1<= n <=50 思路：此题目与B1027有些类似；只是将每行输出的偶数位的字符改为了空格；代码如下：#include <cstdio> int main() { int n; while (...

C语言使用*输出自定义大小的三角形、倒三角形及沙漏

最新发布

03-09

<think>好的，我现在需要帮助用户将现有的C++代码进行并行处理，同时确保线程安全。让我仔细看看用户提供的代码段，理解其功能以及可能存在的线程安全问题。首先，这段代码遍历tags列表中的每个tag，获取对应的网格模型mesh，然后进行一系列处理，最后更新一些共享数据结构，如mModels、mUpdateFlags和mBVHModels。用户希望并行处理这些tag，以提高效率，但必须保证线程安全。首先，我需要分析哪些部分是共享资源，可能引发竞态条件。从代码中可以看到，mModels、mUpdateFlags和mBVHModels都是被多个线程可能同时访问和修改的map结构。此外，在循环内部，当处理每个tag时，会读取和修改这些共享数据结构，特别是在代码末尾的临界区部分，使用锁来设置标志和存储结果。但原来的临界区可能范围不够，或者锁的使用方式不正确。接下来，我需要考虑如何并行化循环。通常，可以使用OpenMP或C++11的线程库来实现循环的并行执行。例如，使用OpenMP的#pragma omp parallel for指令来并行化for循环。但每个循环迭代处理不同的tag，这可能是数据并行的好机会，因为每个tag之间可能是独立的。但需要确保每个线程处理不同的tag，避免竞争。然后，针对共享资源的访问，必须使用互斥锁来保护。例如，当多个线程同时尝试修改mModels或mUpdateFlags时，需要使用互斥锁来确保同一时间只有一个线程在修改这些结构。原来的代码中有一个临界区，但可能范围不够，或者锁的类型不正确。例如，使用OpenMP的临界区可能效率不高，如果每个tag的操作独立，最好使用细粒度锁，比如为每个tag使用单独的锁，或者使用互斥锁来保护整个map结构。此外，需要注意在读取共享数据时是否需要加锁。例如，在检查mModels.find(tag) != mModels.end()时，如果有其他线程正在修改mModels，可能会导致未定义行为，因此需要加锁。同样，访问mUpdateFlags[tag]也需要同步。另一个需要考虑的是，当多个线程同时处理不同的tag时，如果这些tag不同，那么理论上它们之间不会互相干扰。但需要确保每个tag对应的数据在并行处理时是独立的。例如，如果不同线程处理不同的tag，并且每个tag对应的数据在共享map中是独立的条目，那么可能不需要全局锁，而是为每个tag条目使用单独的锁。但这样实现起来可能比较复杂，所以使用一个全局互斥锁可能更简单，尽管会影响性能。或者，可以将每个tag的处理结果先存储在局部变量中，然后在临界区内一次性更新共享数据结构，这样可以减少锁的持有时间。例如，在处理完一个tag后，生成新的newMesh和bvhModel，然后在临界区中将这些结果写入到共享map中，这样临界区只需要保护map的更新操作，而不是整个处理过程。另外，需要注意标准库中的容器（如std::map）在多线程环境下并不同步，因此任何对它们的并发访问都需要外部同步机制。例如，使用std::mutex来保护这些容器的访问。可能还需要考虑内存分配的问题，例如，创建新的mesh对象是否会产生竞争，但在这个代码中，每个newMesh都是独立创建的，所以可能不会有问题，只要不同线程使用的内存区域不重叠。总结可能的线程安全问题点： 1. 访问和修改mModels、mUpdateFlags、mBVHModels时的竞态条件。 2. 在检查mModels是否存在和mUpdateFlags的状态时，可能其他线程正在修改这些结构，导致不一致。 3. 并行处理多个tag时，每个tag的处理是否独立，是否存在共享资源的访问。解决方案步骤： 1. 使用OpenMP或C++11线程库将外层循环并行化，每个线程处理不同的tag。 2. 对共享数据结构的访问和修改使用互斥锁，确保同一时间只有一个线程进行操作。 3. 将临界区的范围最小化，仅在必要时加锁，以提高并发性能。 4. 确保每个线程在处理自己的tag时，不会与其他线程的tag冲突，例如通过将tags分割为不同的区间，或者确保每个tag只被一个线程处理。具体实施：使用OpenMP并行化循环： #pragma omp parallel for for (int i = 0; i < tags.size(); ++i) { // 处理每个tag } 然后，在需要访问共享数据结构的地方使用互斥锁。例如，在检查mModels和mUpdateFlags时，需要加锁。但这样可能会影响性能，因为每次循环迭代都需要多次加锁解锁。或者，可以将整个循环体中的共享数据访问集中到临界区中，但需要评估是否可行。另一种方法是，将每个tag的处理结果存储在临时变量中，然后在临界区中统一更新共享数据结构。例如：在循环内部：处理完newMesh和bvhModel之后，进入临界区，更新mModels、mUpdateFlags和mBVHModels。这样可以减少锁的持有时间。此外，需要注意，在OpenMP中，默认的循环调度是静态的，可能不适用于动态负载均衡的情况。如果每个tag的处理时间差异较大，可能需要使用动态调度。另外，需要确保使用的数据结构是线程安全的，或者通过锁来保护。例如，std::map的operator[]不是线程安全的，因此在并发访问时必须加锁。可能的代码修改：添加互斥锁： std::mutex mtx; #pragma omp parallel for for (int i = 0; i < tags.size(); ++i) { QString tag = tags[i]; // 处理每个tag... // 在访问共享数据前加锁 std::lock_guard<std::mutex> lock(mtx); if (mModels.find(tag) != mModels.end() && !mUpdateFlags[tag]) { // 跳过处理 continue; } // 处理完成后更新共享数据 mUpdateFlags[tag] = false; mModels[tag] = newMesh; mBVHModels[tag] = bvhModel; } 但这样将整个循环体包裹在锁中，会导致并行失效，因为所有线程都会等待锁，变成串行执行。因此，需要更细粒度的锁。正确的方法是将锁仅用于访问和修改共享数据的部分，而处理过程本身不需要锁。例如：在循环内部：处理tag的代码大部分是独立的，只有在检查是否需要处理，以及最后更新共享数据时才需要锁。因此，可以将这些部分用锁保护起来。具体步骤： 1. 在检查mModels和mUpdateFlags时加锁，判断是否需要处理。 2. 如果不需要处理，跳过。 3. 处理完成后，再次加锁，更新共享数据。但这样可能会导致在加锁检查后，另一个线程修改了mUpdateFlags，导致条件变化。例如，线程A检查发现需要处理，开始处理；此时线程B可能已经处理完该tag并设置了mUpdateFlags为false，导致线程A重复处理。不过，根据原代码逻辑，当mUpdateFlags[tag]为false时，会跳过处理。但如果在并行处理中，多个线程可能同时处理同一个tag，这取决于tags列表中是否有重复的tag。假设tags列表中的每个tag是唯一的，即每个i对应不同的tag，那么每个线程处理不同的tag，此时不需要担心多个线程处理同一个tag。但需要确认这一点。如果tags可能有重复，则需要不同的处理方式。假设tags是唯一的，那么每个线程处理不同的tag，此时共享数据结构的访问冲突只发生在不同的tag之间吗？不，因为不同的tag可能对应不同的条目，但std::map的插入和访问可能需要内部结构的修改，因此需要锁保护整个map的操作。因此，正确的做法是，在访问和修改mModels、mUpdateFlags和mBVHModels时，使用互斥锁来保护这些操作。例如：在循环内部： QString tag = tags[i]; const mvl::MyMeshPtr mesh = mModelViewerWidget->getMesh(tag); // 这里需要确认mModelViewerWidget->getMesh是否是线程安全的，如果它内部有共享数据，可能需要加锁 { std::lock_guard<std::mutex> lock(mtx); if (mModels.find(tag) != mModels.end() && !mUpdateFlags[tag]) { continue; // 跳过处理 } } // 处理过程，独立处理newMesh等 // 处理完成后，再次加锁更新共享数据 { std::lock_guard<std::mutex> lock(mtx); mUpdateFlags[tag] = false; mModels[tag] = newMesh; mBVHModels[tag] = createBVHModel(newMesh); } 但这里有一个问题：在检查是否需要处理时，如果另一个线程已经处理了该tag并设置了mUpdateFlags为false，那么当前线程可能会跳过处理。但原代码中，当处理完成后会设置mUpdateFlags[tag]为false，因此如果多个线程处理同一个tag，可能会导致竞争。不过，如果tags列表中的每个i对应不同的tag，则不会有这个问题。因此，用户需要确保tags列表中的每个元素是唯一的，或者在并行处理时使用某种机制防止同一个tag被多个线程处理。如果tags中存在重复的tag，那么上述代码会有问题，因为多个线程可能同时处理同一个tag，导致竞态条件。因此，用户需要明确tags是否可能包含重复项。如果可能，需要处理这种情况，例如使用互斥锁保护每个tag的处理，或者使用并发容器。假设tags中的每个元素是唯一的，那么每个线程处理不同的tag，此时在检查和处理时的锁只需要保护对map的访问，而不是整个处理过程。因此，修改后的代码可能如下：使用OpenMP并行化循环： #include <mutex> std::mutex mtx; #pragma omp parallel for for (int i = 0; i < tags.size(); ++i) { QString tag = tags[i]; const mvl::MyMeshPtr mesh = mModelViewerWidget->getMesh(tag); if (!mesh || !mesh->vert.size() || !mesh->face.size()) continue; // 检测是否需要处理该tag bool skip = false; { std::lock_guard<std::mutex> lock(mtx); if (mModels.find(tag) != mModels.end() && !mUpdateFlags[tag]) { skip = true; } } if (skip) continue; // 处理过程，独立创建mesh等，这部分不需要锁 mvl::MyMeshPtr newMesh(new mvl::MyMesh); vcg::tri::Append<mvl::MyMesh, mvl::MyMesh>::MeshCopy(*newMesh, *mesh); // 删除被标记的面片和点 // ... 原处理代码 // 应用变换矩阵 Eigen::Matrix4f transMat = mModelViewerWidget->getMeshMatrix(tag); vcg::Matrix44<float> mat; mat.FromEigenMatrix(transMat); vcg::tri::UpdatePosition<mvl::MyMesh>::Matrix(*newMesh, mat); // 创建BVH模型 auto bvhModel = createBVHModel(newMesh); // 更新共享数据 { std::lock_guard<std::mutex> lock(mtx); mUpdateFlags[tag] = false; mModels[tag] = newMesh; mBVHModels[tag] = bvhModel; } } 这样，每个线程处理不同的tag，访问共享数据时使用互斥锁保护。但需要注意以下几点： 1. mModelViewerWidget->getMesh(tag)和getMeshMatrix(tag)必须是线程安全的，即它们内部没有共享数据需要同步，或者这些方法本身是只读的。如果这些方法需要访问共享数据，可能需要加锁。 2. createBVHModel(newMesh)是否线程安全，即该函数是否修改共享状态或使用全局资源。如果是独立的，则没问题。 3. 在检查是否需要处理时，加锁的范围是否正确。例如，在检查mModels和mUpdateFlags时，如果另一个线程正在更新该tag的数据，可能导致条件判断不准确。但由于每个tag只被一个线程处理（假设tags唯一），所以不会发生这种情况。此外，原代码中的临界区可能只是保护了更新mUpdateFlags和mModels的部分，而并行化后需要将整个更新过程用锁保护。另外，如果mUpdateFlags的某个tag在并行处理过程中被其他操作修改，可能需要重新考虑同步机制，但根据原代码逻辑，处理完成后会将mUpdateFlags[tag]设为false，之后除非其他地方再次设置，否则不会再次处理。另一个可能的优化是使用读写锁（如std::shared_mutex），因为在检查mModels和mUpdateFlags时是读操作，而更新时是写操作。但需要根据实际情况判断是否值得。总结： - 使用OpenMP的并行循环处理每个tag。 - 使用互斥锁保护对共享数据结构（mModels、mUpdateFlags、mBVHModels）的访问。 - 确保处理过程中调用的其他函数（如getMesh、createBVHModel）是线程安全的。 - 假设tags列表中的每个元素唯一，避免多个线程处理同一tag导致的竞争。可能的代码调整后的版本如下，添加了互斥锁，并将临界区替换为C++的std::mutex。</think>为了使这段代码线程安全并实现并行处理，需要重点关注共享资源的同步问题。以下是分步解决方案： 1. **并行化循环结构** ```cpp #include <mutex> std::mutex resource_mutex; // 全局互斥锁 #pragma omp parallel for for (int i = 0; i < tags.size(); ++i) { QString tag = tags[i]; // ... 原有获取mesh的代码不变 ... ``` 2. **共享资源访问保护** ```cpp // 双重检查锁定模式 bool need_process = true; { std::lock_guard<std::mutex> lock(resource_mutex); if (mModels.find(tag) != mModels.end() && !mUpdateFlags[tag]) { need_process = false; } } if (!need_process) continue; ``` 3. **独立数据处理阶段**（无需加锁）： ```cpp // 创建独立mesh副本 mvl::MyMeshPtr newMesh(new mvl::MyMesh); vcg::tri::Append<mvl::MyMesh, mvl::MyMesh>::MeshCopy(*newMesh, *mesh); // 执行删除操作和网格清理... // 应用变换矩阵... // 创建BVH模型... ``` 4. **原子化更新操作**： ```cpp // 最终更新共享资源 std::lock_guard<std::mutex> lock(resource_mutex); mUpdateFlags[tag] = false; mModels[tag] = newMesh; mBVHModels[tag] = createBVHModel(newMesh); } ``` **关键改进点**： 1. 使用OpenMP的`#pragma omp parallel for`实现循环级并行 2. 通过`std::mutex`保护三个共享资源： - `mModels`（模型存储） - `mUpdateFlags`（更新标志） - `mBVHModels`（BVH加速结构） 3. 采用`双重检查锁定`模式： - 快速路径检查：无锁读取（依赖tags唯一性） - 安全路径检查：加锁验证 4. 保持临界区最小化：仅保护资源更新操作 **注意事项**： 1. 确保`tags`集合中的元素唯一，避免不同线程处理相同tag 2. 验证`getMesh()`和`getMeshMatrix()`方法的线程安全性 3. 建议使用`std::map<QString, std::mutex>`实现细粒度锁（当tags数量较大时） 4. 考虑使用`std::atomic`优化标志位的原子操作 **性能优化建议**： ```cpp // 使用读写锁优化读多写少场景 #include <shared_mutex> std::shared_mutex rw_mutex; // 读取时使用共享锁 { std::shared_lock<std::shared_mutex> lock(rw_mutex); // 执行读操作 } // 写入时使用排他锁 { std::unique_lock<std::shared_mutex> lock(rw_mutex); // 执行写操作 } ``` **数学表达同步原理**：设线程数为$N$，临界区执行时间为$t_c$，总执行时间近似为： $$ T_{parallel} \approx \frac{T_{serial}}{N} + N \cdot t_c $$ 需确保$N \cdot t_c \ll T_{serial}$才能获得加速效果。通过上述改造，既保持了原有功能，又通过合理的锁机制实现了线程安全，可充分利用多核处理器的计算能力。