[已解决]三个勇士谁活到最后

@0.0@sos

在瓦尼亚的土地上，亚伦、鲍勃和查理为他们中哪一个是有史以来最伟大的拼图家而争论。为了一劳永逸地结束这场争论，他们同意决斗到底。亚伦是一个糟糕的射手，命中目标的概率只有1/3。鲍勃稍微好一点，命中目标的概率是1/2。查理是一名专业的射手，从不失误。命中意味着杀死，被击中的人退出决斗。
为了弥补射击技术上的不公平，决定选手们轮流射击，先是亚伦，然后是鲍勃，然后是查理。循环会一直重复，直到有一个人站着。而那个人将作为有史以来最伟大的谜团而被人们铭记。
A.编写一个函数来模拟单个快照。它应该使用以下声明：无效射击（bool和targetAlive，double accuracy）；这将通过生成一个介于0和1之间的随机数，模拟某人以给定的精度向TargetLive射击。如果随机数小于准确度，则会命中目标，并且应将TargetLive设置为false。
例如，如果Bob向Charlie开枪，这可以被调用为：
射击（Charlielive，0.5）；
这里，charlieAlive是一个布尔变量，指示Charlie是否还活着。在进入步骤b之前，使用驱动程序测试您的功能。
B一个明显的策略是，每个人都要射向仍然活着的最准确的射手，因为这个射手是最致命的，并且有最好的反击机会。编写第二个名为startDuel的函数，该函数使用shot函数来使用此策略模拟整个决斗。它应该循环直到只剩下一个参赛者，根据射击的对象调用射击功能，并根据正确的目标和命中目标的概率调用射击功能。函数应该返回一个变量，指示谁赢得了决斗。
C在main函数中，在循环中调用startDuel函数1000次，记录每个参赛者获胜的次数。输出当每个人都使用最精确的射击策略时，每个参赛者获胜的概率。
D一个违反直觉的策略是Aaron故意错过他的第一枪。此后，每个人都会采用向活着的最准确的射手射击的策略。这一策略意味着Aaron肯定能活过第一轮，因为Bob和Charlie会互相射击。修改程序以适应此新策略，并输出每个参赛者的获胜概率。

最佳答案

月排行榜 / 总排行榜

人造人

2021-10-9 21:13:15

1. 不知道答案，不知道写的对不对
2. 没有完全按照题目要求写
3. 没有看懂要求 D，我的理解是 Aaron 不参与第 0 轮射击
4. 作业要自己写

A ~ C

1. #include <iostream>
   
2. #include <random>
   
3. #include <ctime>
   
4. #include <string>
   
5. #include <vector>
   
6. 
   
7. struct human_t {
   
8.     std::string name;
   
9.     double accuracy;
   
10. };
    
11. 
    
12. std::default_random_engine re(std::time(NULL));
    
13. 
    
14. size_t shoot(double accuracy) {
    
15.     std::uniform_real_distribution<double> urd(0, 1);
    
16.     if(urd(re) < accuracy) return true;
    
17.     return false;
    
18. }
    
19. 
    
20. size_t get_attack_target(const std::vector<human_t> &people, const std::vector<bool> &alive, size_t self) {
    
21.     size_t max_accuracy = 0;
    
22.     for(size_t i = 0; i < people.size(); ++i) {
    
23.         if(i == self) continue;
    
24.         if(!alive[i]) continue;
    
25.         if(people[max_accuracy].accuracy < people[i].accuracy) max_accuracy = i;
    
26.     }
    
27.     return max_accuracy;
    
28. }
    
29. 
    
30. size_t get_winner(const std::vector<bool> &alive) {
    
31.     size_t winner = 0;
    
32.     for(size_t i = 0; i < alive.size(); ++i) {
    
33.         if(alive[i] && !alive[winner]) winner = i;
    
34.         if(alive[i] && alive[winner] && winner != i) return -1;
    
35.     }
    
36.     return winner;
    
37. }
    
38. 
    
39. size_t startDuel(const std::vector<human_t> &people) {
    
40.     std::vector<bool> alive(people.size(), true);
    
41.     size_t winner;
    
42.     for(size_t i = 0; (winner = get_winner(alive)) == (size_t)-1; i = (i + 1) % people.size()) {
    
43.         if(alive[i]) alive[get_attack_target(people, alive, i)] = !shoot(people[i].accuracy);
    
44.     }
    
45.     return winner;
    
46. }
    
47. 
    
48. int main() {
    
49.     std::vector<human_t> people = {
    
50.         {"Aaron", 1.0 / 3},
    
51.         {"Bob", 1.0 / 2},
    
52.         {"Charlie", 1.0}
    
53.     };
    
54.     std::vector<size_t> winners(people.size());
    
55.     for(size_t i = 0; i < 1000; ++i) ++winners[startDuel(people)];
    
56.     for(size_t i = 0; i < people.size(); ++i) {
    
57.         std::cout << people[i].name << ": " << winners[i] / 1000.0 << std::endl;
    
58.     }
    
59.     return 0;
    
60. }
    

复制代码

D

1. #include <iostream>
   
2. #include <random>
   
3. #include <ctime>
   
4. #include <string>
   
5. #include <vector>
   
6. 
   
7. struct human_t {
   
8.     std::string name;
   
9.     double accuracy;
   
10. };
    
11. 
    
12. std::default_random_engine re(std::time(NULL));
    
13. 
    
14. size_t shoot(double accuracy) {
    
15.     std::uniform_real_distribution<double> urd(0, 1);
    
16.     if(urd(re) < accuracy) return true;
    
17.     return false;
    
18. }
    
19. 
    
20. size_t get_attack_target(const std::vector<human_t> &people, const std::vector<bool> &alive, size_t self) {
    
21.     size_t max_accuracy = 0;
    
22.     for(size_t i = 0; i < people.size(); ++i) {
    
23.         if(i == self) continue;
    
24.         if(!alive[i]) continue;
    
25.         if(people[max_accuracy].accuracy < people[i].accuracy) max_accuracy = i;
    
26.     }
    
27.     return max_accuracy;
    
28. }
    
29. 
    
30. size_t get_winner(const std::vector<bool> &alive) {
    
31.     size_t winner = 0;
    
32.     for(size_t i = 0; i < alive.size(); ++i) {
    
33.         if(alive[i] && !alive[winner]) winner = i;
    
34.         if(alive[i] && alive[winner] && winner != i) return -1;
    
35.     }
    
36.     return winner;
    
37. }
    
38. 
    
39. size_t startDuel(const std::vector<human_t> &people) {
    
40.     std::vector<bool> alive(people.size(), true);
    
41.     size_t winner;
    
42.     size_t count = 0;
    
43.     for(size_t i = 0; (winner = get_winner(alive)) == (size_t)-1; i = (i + 1) % people.size()) {
    
44.         if(count++ != 0) {
    
45.             if(alive[i]) alive[get_attack_target(people, alive, i)] = !shoot(people[i].accuracy);
    
46.         }
    
47.     }
    
48.     return winner;
    
49. }
    
50. 
    
51. int main() {
    
52.     std::vector<human_t> people = {
    
53.         {"Aaron", 1.0 / 3},
    
54.         {"Bob", 1.0 / 2},
    
55.         {"Charlie", 1.0}
    
56.     };
    
57.     std::vector<size_t> winners(people.size());
    
58.     for(size_t i = 0; i < 1000; ++i) ++winners[startDuel(people)];
    
59.     for(size_t i = 0; i < people.size(); ++i) {
    
60.         std::cout << people[i].name << ": " << winners[i] / 1000.0 << std::endl;
    
61.     }
    
62.     return 0;
    
63. }
    

复制代码

跳转到最佳答案楼层

人造人

1. 不知道答案，不知道写的对不对
2. 没有完全按照题目要求写
3. 没有看懂要求 D，我的理解是 Aaron 不参与第 0 轮射击
4. 作业要自己写

A ~ C

1. #include <iostream>
   
2. #include <random>
   
3. #include <ctime>
   
4. #include <string>
   
5. #include <vector>
   
6. 
   
7. struct human_t {
   
8.     std::string name;
   
9.     double accuracy;
   
10. };
    
11. 
    
12. std::default_random_engine re(std::time(NULL));
    
13. 
    
14. size_t shoot(double accuracy) {
    
15.     std::uniform_real_distribution<double> urd(0, 1);
    
16.     if(urd(re) < accuracy) return true;
    
17.     return false;
    
18. }
    
19. 
    
20. size_t get_attack_target(const std::vector<human_t> &people, const std::vector<bool> &alive, size_t self) {
    
21.     size_t max_accuracy = 0;
    
22.     for(size_t i = 0; i < people.size(); ++i) {
    
23.         if(i == self) continue;
    
24.         if(!alive[i]) continue;
    
25.         if(people[max_accuracy].accuracy < people[i].accuracy) max_accuracy = i;
    
26.     }
    
27.     return max_accuracy;
    
28. }
    
29. 
    
30. size_t get_winner(const std::vector<bool> &alive) {
    
31.     size_t winner = 0;
    
32.     for(size_t i = 0; i < alive.size(); ++i) {
    
33.         if(alive[i] && !alive[winner]) winner = i;
    
34.         if(alive[i] && alive[winner] && winner != i) return -1;
    
35.     }
    
36.     return winner;
    
37. }
    
38. 
    
39. size_t startDuel(const std::vector<human_t> &people) {
    
40.     std::vector<bool> alive(people.size(), true);
    
41.     size_t winner;
    
42.     for(size_t i = 0; (winner = get_winner(alive)) == (size_t)-1; i = (i + 1) % people.size()) {
    
43.         if(alive[i]) alive[get_attack_target(people, alive, i)] = !shoot(people[i].accuracy);
    
44.     }
    
45.     return winner;
    
46. }
    
47. 
    
48. int main() {
    
49.     std::vector<human_t> people = {
    
50.         {"Aaron", 1.0 / 3},
    
51.         {"Bob", 1.0 / 2},
    
52.         {"Charlie", 1.0}
    
53.     };
    
54.     std::vector<size_t> winners(people.size());
    
55.     for(size_t i = 0; i < 1000; ++i) ++winners[startDuel(people)];
    
56.     for(size_t i = 0; i < people.size(); ++i) {
    
57.         std::cout << people[i].name << ": " << winners[i] / 1000.0 << std::endl;
    
58.     }
    
59.     return 0;
    
60. }
    

复制代码

D

1. #include <iostream>
   
2. #include <random>
   
3. #include <ctime>
   
4. #include <string>
   
5. #include <vector>
   
6. 
   
7. struct human_t {
   
8.     std::string name;
   
9.     double accuracy;
   
10. };
    
11. 
    
12. std::default_random_engine re(std::time(NULL));
    
13. 
    
14. size_t shoot(double accuracy) {
    
15.     std::uniform_real_distribution<double> urd(0, 1);
    
16.     if(urd(re) < accuracy) return true;
    
17.     return false;
    
18. }
    
19. 
    
20. size_t get_attack_target(const std::vector<human_t> &people, const std::vector<bool> &alive, size_t self) {
    
21.     size_t max_accuracy = 0;
    
22.     for(size_t i = 0; i < people.size(); ++i) {
    
23.         if(i == self) continue;
    
24.         if(!alive[i]) continue;
    
25.         if(people[max_accuracy].accuracy < people[i].accuracy) max_accuracy = i;
    
26.     }
    
27.     return max_accuracy;
    
28. }
    
29. 
    
30. size_t get_winner(const std::vector<bool> &alive) {
    
31.     size_t winner = 0;
    
32.     for(size_t i = 0; i < alive.size(); ++i) {
    
33.         if(alive[i] && !alive[winner]) winner = i;
    
34.         if(alive[i] && alive[winner] && winner != i) return -1;
    
35.     }
    
36.     return winner;
    
37. }
    
38. 
    
39. size_t startDuel(const std::vector<human_t> &people) {
    
40.     std::vector<bool> alive(people.size(), true);
    
41.     size_t winner;
    
42.     size_t count = 0;
    
43.     for(size_t i = 0; (winner = get_winner(alive)) == (size_t)-1; i = (i + 1) % people.size()) {
    
44.         if(count++ != 0) {
    
45.             if(alive[i]) alive[get_attack_target(people, alive, i)] = !shoot(people[i].accuracy);
    
46.         }
    
47.     }
    
48.     return winner;
    
49. }
    
50. 
    
51. int main() {
    
52.     std::vector<human_t> people = {
    
53.         {"Aaron", 1.0 / 3},
    
54.         {"Bob", 1.0 / 2},
    
55.         {"Charlie", 1.0}
    
56.     };
    
57.     std::vector<size_t> winners(people.size());
    
58.     for(size_t i = 0; i < 1000; ++i) ++winners[startDuel(people)];
    
59.     for(size_t i = 0; i < people.size(); ++i) {
    
60.         std::cout << people[i].name << ": " << winners[i] / 1000.0 << std::endl;
    
61.     }
    
62.     return 0;
    
63. }
    

复制代码

jhq999

1. #include "stdio.h"
   
2. #include "stdlib.h"
   
3. #include <time.h>
   
4. struct SHOOT
   
5. {
   
6.         int  name;
   
7.         bool isAlive;
   
8.         double prob;
   
9.         double  shootnum;
   
10.         double  sezong;
    
11.         double live;
    
12. };
    
13. 
    
14. void Shoot(bool & targetAlive,double accuracy);
    
15. int StartDuel(SHOOT *inshts,int shtnum);
    
16. void Probsort(SHOOT *inshts,int shtnum);
    
17. int main(int argv,char argc[])
    
18. {
    
19.        
    
20.         SHOOT sht[3]={0};
    
21.         sht[0].name=0,sht[0].isAlive=1,sht[0].prob=1.0/3.0;
    
22.         sht[1].name=1,sht[1].isAlive=1,sht[1].prob=1.0/2.0;
    
23.         sht[2].name=2,sht[2].isAlive=1,sht[2].prob=1.0;
    
24.         srand(unsigned int(time(NULL)));
    
25.         for (int i = 0; i < 1000; i++)
    
26.         {
    
27.                 sht[0].isAlive=1;
    
28.                 sht[1].isAlive=1;
    
29.                 sht[2].isAlive=1;
    
30.                 int l=StartDuel(sht,3);
    
31.                 //printf("\nLive is %d\n",l);
    
32.         }
    
33.         for (int i = 0; i < 3 ;i++)
    
34.         {
    
35.                 if (sht[i].shootnum)
    
36.                 {
    
37. 
    
38.                
    
39.                         printf ("%d prob is %.2lf liveprob is %.2lf\n",sht[i].name,sht[i].sezong/sht[i].shootnum,sht[i].live/1000);
    
40.                 }
    
41.                 else
    
42.                 {
    
43.                         printf ("%d prob is %.2lf liveprob is %.2lf\n",sht[i].name,sht[i].prob,sht[i].live/1000);
    
44.                 }
    
45.                
    
46. 
    
47.         }
    
48. 
    
49.         return 0;
    
50. }
    
51. void Probsort(SHOOT *inshts,int shtnum)
    
52. {
    
53.         bool flag=true;
    
54.         SHOOT tmp={0};
    
55.         for (int i = 0; i < shtnum; i++)
    
56.         {
    
57.                 for (int j = i+1; j < shtnum; j++)
    
58.                 {
    
59.                         if (inshts[j].prob<inshts[i].prob)
    
60.                         {
    
61.                                 tmp=inshts[i];
    
62.                                 inshts[i]=inshts[j];
    
63.                                 inshts[j]=tmp;
    
64.                                 flag=false;
    
65.                         }
    
66. 
    
67.                 }
    
68.                 if (flag)
    
69.                 {
    
70.                         break;
    
71.                 }
    
72.         }
    
73. }
    
74. int StartDuel(SHOOT *inshts,int shtnum)
    
75. {
    
76.         bool isexit=0;
    
77.         int i=0,j=0,live=-1,start=1;
    
78. 
    
79.         while (true)
    
80.         {
    
81.                 isexit=1;
    
82.                 for (i = start; i < shtnum; i++)
    
83.                 {
    
84.                         start=0;
    
85.                         if (inshts[i].isAlive)
    
86.                         {
    
87.                                 for (j = shtnum-1; j>=0; j--)
    
88.                                 {
    
89.                                         if (inshts[j].isAlive&&i!=j)
    
90.                                         {
    
91.                                                 inshts[i].shootnum++;
    
92.                                                 Shoot(inshts[j].isAlive,inshts[i].prob);
    
93.                                    
    
94.                                                 if (!inshts[j].isAlive)
    
95.                                                 {
    
96.                                                         inshts[i].sezong++;
    
97.                                                         live=i;
    
98.                                                         //printf("%d kill %d,",inshts[i].name,inshts[j].name);
    
99. 
    
100. 
     
101.                                                         if (inshts[j].shootnum)
     
102.                                                         {
     
103.                                                                 inshts[j].prob=inshts[j].prob>inshts[j].sezong/inshts[j].shootnum?
     
104.                                                         inshts[j].prob:inshts[j].sezong/inshts[j].shootnum;
     
105.                                                         }
     
106.                                                 }
     
107.                                                 isexit=0;
     
108.                                                 break;
     
109.                                         }
     
110.                                 }
     
111.                         }
     
112. 
     
113.                 }
     
114.                 if (isexit)
     
115.                 {
     
116.        
     
117.                         break;
     
118.                 }
     
119.         }
     
120.        
     
121. 
     
122.         //Probsort(inshts,shtnum);
     
123.         inshts[live].live++;
     
124.         return inshts[live].name;
     
125. }
     
126. void Shoot(bool & targetAlive,double accuracy)
     
127. {
     
128. 
     
129. 
     
130.         int i=0;
     
131.         //for (; i < rand()%100; i++);
     
132.         i=(rand()%100);
     
133. 
     
134.         targetAlive=i>int(accuracy*100)?1:0;
     
135. }

复制代码