一个C#和C++执行效率对比的简单实例

这里用一个算法题进行比较。

原题是见http://acm.hdu.edu.cn/showproblem.php?pid=4090，登载在http://blog.csdn.net/woshi250hua/article/details/7997550

作者提供了一个比较快的答案。

我之前也尝试做了一个，没有用递归，但也没有用作者使用的格局保存的剪枝方案，比较慢，随后看了作者的方案后再整合进了一个基本等效的格局保存逻辑。

以下是作者的C++程序的基本等价的C#程序，

  1 using System.Collections.Generic;
  2
  3 namespace HDU4090
  4 {
  5     internal class SolveGemAndPrince2
  6     {
  7         private const int Max = 10;
  8
  9         private struct Node
 10         {
 11             public int X;
 12             public int Y;
 13         }
 14
 15         private readonly Node[] _qu = new Node[Max*Max];
 16         private readonly Dictionary<string, int> _hash = new Dictionary<string, int>();
 17
 18         private readonly int[,] _dir = new[,]
 19             {
 20                 {1, 0}, {1, 1}, {1, -1}, {-1, 0}, {-1, -1}, {-1, 1}, {0, 1}, {0, -1}
 21             };
 22
 23         private static void Change(int[,] mmap, ref int n, ref int m)
 24         {
 25             int i, j, tn = 0, tm = 0;
 26             var k = new int[10];
 27             for (j = 0; j < m; ++j)
 28             {
 29
 30                 k[j] = 0;
 31                 for (i = 0; i < n; ++i)
 32                     if (mmap[i, j] != 0) mmap[k[j]++, j] = mmap[i, j];
 33             }
 34             for (j = 0; j < m; ++j)
 35                 if (k[j] != 0)
 36                 {
 37
 38                     for (i = 0; i < k[j]; ++i)
 39                         mmap[i, tm] = mmap[i, j];
 40                     for (i = k[j]; i < n; ++i)
 41                         mmap[i, tm] = 0;
 42                     tm++;
 43                     if (k[j] > tn) tn = k[j];
 44                 }
 45             n = tn;
 46             m = tm;
 47         }
 48
 49         private int Ok(int[,] temp, int[,] vis, int i, int j, int n, int m)
 50         {
 51             var cnt = 0;
 52             int head = 0, tail = 0;
 53             Node cur;
 54
 55             cur.X = i;
 56             cur.Y = j;
 57             _qu[head++] = cur;
 58             vis[cur.X,cur.Y] = 1;
 59
 60             while (tail < head)
 61             {
 62                 cur = _qu[tail++];
 63                 cnt++;
 64                 int k;
 65                 for (k = 0; k < 8; ++k)
 66                 {
 67                     Node next;
 68                     next.X = cur.X + _dir[k,0];
 69                     next.Y = cur.Y + _dir[k,1];
 70                     if (next.X >= 0 && next.X < n
 71                         && next.Y >= 0 && next.Y < m
 72                         && vis[next.X,next.Y] == 0
 73                         && temp[next.X,next.Y] == temp[i,j])
 74                     {
 75
 76                         _qu[head++] = next;
 77                         vis[next.X,next.Y] = 1;
 78                         temp[next.X,next.Y] = 0;
 79                     }
 80                 }
 81             }
 82             temp[i,j] = 0;
 83             return cnt >= 3 ? cnt : 0;
 84         }
 85
 86         static string GetHash(int[,] temp,int n,int m)
 87         {
 88             var s = "";
 89             for (var i = 0; i < n; ++i)
 90                 for (var j = 0; j < m; ++j)
 91                     s += temp[i,j] + '0';
 92             return s;
 93         }
 94
 95         static void Mem(int[,] temp, int[,] mmap, int n, int m)
 96         {
 97             for (var i = 0; i < Max; i++ )
 98                 for (var j = 0; j < Max; j++)
 99                     temp[i, j] = 0;
100             for (var i = 0; i < n; ++i)
101                 for (var j = 0; j < m; ++j)
102                     temp[i,j] = mmap[i,j];
103         }
104
105         int Dfs(int[,] mmap,int n,int m)
106         {
107
108             if (n*m < 3) return 0;
109             var temp = new int[Max,Max];
110             int i, j;
111             var vis = new int[Max,Max];
112             var cnt = 0;
113
114             for (i = 0; i < n; ++i)
115                 for (j = 0; j < m; ++j)
116                     if (vis[i,j]==0 && mmap[i,j]!=0)
117                     {
118                         Mem(temp, mmap, n, m);
119                         var ans = Ok(temp, vis, i, j, n, m);
120                         if (ans >= 3)
121                         {
122                             ans = ans*ans;
123                             int tn = n, tm = m;
124                             Change(temp, ref tn, ref tm);
125                             var s = GetHash(temp, tn, tm);
126 #if true
127                             if (!_hash.ContainsKey(s))
128                                 ans += Dfs(temp, tn, tm);
129                             else ans += _hash[s];
130 #else
131                             ans += Dfs(temp, tn, tm);
132 #endif
133                             if (ans > cnt) cnt = ans;
134                         }
135                     }
136
137             _hash[GetHash(mmap, n, m)] = cnt;
138             return cnt;
139         }
140
141         public int Solve(int n, int m, int k, int[,] gems)
142         {
143             _hash.Clear();
144             return Dfs(gems, n, m);
145         }
146     }
147 }

再接下来是我的方案（纯粹凑热闹，没有参与这里的对比），

  1 using System;
  2 using System.Collections.Generic;
  3
  4 namespace HDU4090
  5 {
  6     public class SolveGemAndPrince
  7     {
  8         #region Nested types
  9
 10         class Node
 11         {
 12             #region Nested types
 13
 14             public class Gem
 15             {
 16                 public int Row { get; set; }
 17                 public int Col { get; set; }
 18             }
 19
 20             public class Connective
 21             {
 22                 public readonly List<Gem> Connected = new List<Gem>();
 23             }
 24
 25             #endregion
 26
 27             #region Properties
 28
 29             private int[,] Gems { get; set; }
 30             public List<Connective> Connectives { get; private set; }
 31             public int Try { get; set; }
 32             public int Score { get; private set; }
 33
 34             #endregion
 35
 36             #region Constructors
 37
 38             public Node(int rows, int cols, int[,] gems, int iniScore)
 39             {
 40                 _rows = rows;
 41                 _cols = cols;
 42                 Score = iniScore;
 43                 Connectives = new List<Connective>();
 44                 Gems = gems;
 45                 Segment();
 46             }
 47
 48             #endregion
 49
 50             #region Methods
 51
 52             public string GetHash()
 53             {
 54                 var hash = "";
 55                 foreach (var gem in Gems)
 56                 {
 57                     hash += gem.ToString() + '0';
 58                 }
 59                 return hash;
 60             }
 61
 62             void AddToConnective(Connective connective, bool[,] visited, int r, int c)
 63             {
 64                 visited[r, c] = true;
 65                 connective.Connected.Add(new Gem { Row = r, Col = c });
 66                 var imin = Math.Max(0, r - 1);
 67                 var imax = Math.Min(_rows - 1, r + 1);
 68                 var jmin = Math.Max(0, c - 1);
 69                 var jmax = Math.Min(_cols - 1, c + 1);
 70                 var cur = Gems[r, c];
 71                 for (var i = imin; i <= imax; i++)
 72                 {
 73                     for (var j = jmin; j <= jmax; j++)
 74                     {
 75                         if (visited[i, j]) continue;
 76                         var val = Gems[i, j];
 77                         if (val == cur)
 78                         {   // TODO recursive, improve it
 79                             AddToConnective(connective, visited, i, j);
 80                         }
 81                     }
 82                 }
 83             }
 84
 85             void Segment()
 86             {
 87                 var visited = new bool[_rows, _cols];
 88                 for (var i = 0; i < _rows; i++)
 89                 {
 90                     for (var j = 0; j < _cols; j++)
 91                     {
 92                         if (visited[i, j] || Gems[i, j] == 0) continue;
 93                         var connective = new Connective();
 94                         AddToConnective(connective, visited, i, j);
 95                         if (connective.Connected.Count < 3) continue;
 96                         Connectives.Add(connective);
 97                     }
 98                 }
 99             }
100
101             public Node Action(int path)
102             {
103                 var connective = Connectives[path];
104                 var gems = Copy();
105                 var firstNonZeroRow = _rows;
106                 var firstNonZeroCol = 0;
107
108                 foreach (var gem in connective.Connected)
109                 {
110                     gems[gem.Row, gem.Col] = 0;
111                 }
112                 // processes falling
113                 var newcols = 0;
114                 for (var i = 0; i < _cols; i++)
115                 {
116                     var k = _rows - 1;
117                     for (var j = _rows - 1; j >= 0; j--)
118                     {
119                         if (gems[j, i] > 0)
120                         {
121                             gems[k--, i] = gems[j, i];
122                         }
123                     }
124                     for (var t = 0; t <= k; t++)
125                     {
126                         gems[t, i] = 0;
127                     }
128                     if (k + 1 < firstNonZeroRow) firstNonZeroRow = k + 1;
129                     if (k + 1 < _rows)
130                     {   // non-empty
131                         newcols++;
132                     }
133                     else if (i == firstNonZeroCol)
134                     {
135                         firstNonZeroCol = i;
136                     }
137                 }
138                 // processes shifting
139
140                 var newrows = _rows - firstNonZeroRow;
141                 var newgems = new int[newrows, newcols];
142                 var tcol = 0;
143                 for (var j = firstNonZeroCol; j < _cols; j++)
144                 {
145                     if (gems[_rows - 1, j] == 0) continue;  // empty column
146                     for (var i = firstNonZeroRow; i < _rows; i++)
147                     {
148                         newgems[i - firstNonZeroRow, tcol] = gems[i, j];
149                     }
150                     tcol++;
151                 }
152                 var count = connective.Connected.Count;
153                 var scoreInc = count*count;
154                 return new Node(newrows, newcols, newgems, Score + scoreInc);
155             }
156
157             int[,] Copy()
158             {
159                 var gems = new int[_rows,_cols];
160                 for (var i = 0; i < _rows; i++)
161                 {
162                     for (var j =0; j < _cols; j++)
163                     {
164                         gems[i, j] = Gems[i, j];
165                     }
166                 }
167                 return gems;
168             }
169
170             #endregion
171
172             #region Fields
173
174             private readonly int _rows;
175             private readonly int _cols;
176
177             #endregion
178         }
179
180         #endregion
181
182         #region Methods
183
184         /// <summary>
185         ///  Solves the gem-and-prince problem presented in HDU-4090
186         ///  http://acm.hdu.edu.cn/showproblem.php?pid=4090
187         ///  found from the post at
188         ///  http://blog.csdn.net/woshi250hua/article/details/7997550
189         /// </summary>
190         /// <param name="n">The number of rows the gem grid contains; might well be ignored in C#</param>
191         /// <param name="m">The number of columns the gem grid contains; might well be ignored in C#</param>
192         /// <param name="k">The inclusive upper bound of gem values of which the minimum is always 0 which means there is no gem</param>
193         /// <param name="gems">The initial grid of gems</param>
194         /// <returns>The highest score that can be achieved by the solution</returns>
195         public int Solve(int n, int m, int k, int[,] gems)
196         {
197             _records.Clear();
198             var root = new Node(n, m, gems, 0);
199             var stack = new Stack<Node>();
200             var highest = 0;
201             stack.Push(root);
202
203             while (stack.Count > 0)
204             {
205                 var node = stack.Pop();
206
207
208                 if (node.Try >= node.Connectives.Count) continue;
209                 var newNode = node.Action(node.Try);
210                 node.Try++;
211                 stack.Push(node);
212
213 #if true    // optimisation
214                 var hash = newNode.GetHash();
215                 if (_records.ContainsKey(hash))
216                 {
217                     var oldScore = _records[hash];
218                     if (newNode.Score <= oldScore)
219                         continue;
220                 }
221
222                 _records[hash] = newNode.Score;
223 #endif
224
225                 if (newNode.Score > highest)
226                 {
227                     highest = newNode.Score;
228                 }
229                 stack.Push(newNode);
230             }
231             return highest;
232         }
233
234         #endregion
235
236         #region Fields
237
238         readonly Dictionary<string,int> _records = new Dictionary<string, int>();
239
240         #endregion
241     }
242 }

测试程序和样本：

  1 using System;
  2
  3 namespace HDU4090
  4 {
  5     class Program
  6     {
  7         struct Sample
  8         {
  9             public int N, M, K;
 10             public int[,] Data;
 11         }
 12
 13         private static Sample[] Samples = new Sample[]
 14             {
 15                 new Sample
 16                     {
 17                         N = 5,
 18                         M = 5,
 19                         K = 5,
 20                         Data =
 21                             new[,]
 22                                 {
 23                                     {1, 2, 3, 4, 5},
 24                                     {1, 2, 2, 2, 1},
 25                                     {1, 2, 1, 2, 1},
 26                                     {1, 2, 2, 2, 2},
 27                                     {1, 2, 3, 3, 5}
 28                                 }
 29                     },
 30                 new Sample
 31                     {
 32                         N = 3,
 33                         M = 3,
 34                         K = 3,
 35                         Data =
 36                             new[,]
 37                                 {
 38                                     {1, 1, 1},
 39                                     {1, 1, 1},
 40                                     {2, 3, 3}
 41                                 }
 42                     },
 43                 new Sample
 44                     {
 45                         N = 4,
 46                         M = 4,
 47                         K = 3,
 48                         Data =
 49                             new[,]
 50                                 {
 51                                     {1, 1, 1, 3},
 52                                     {2, 1, 2, 3},
 53                                     {1, 2, 1, 3},
 54                                     {3, 3, 3, 3}
 55                                 }
 56                     },
 57                 new Sample
 58                     {
 59                         N = 4,
 60                         M = 4,
 61                         K = 2,
 62                         Data =
 63                             new[,]
 64                                 {
 65                                     {1, 2, 1, 2},
 66                                     {2, 1, 2, 1},
 67                                     {1, 2, 1, 2},
 68                                     {2, 1, 2, 1}
 69                                 }
 70                     },
 71                 new Sample
 72                     {
 73                         N = 8,
 74                         M = 8,
 75                         K = 6,
 76                         Data =
 77                             new[,]
 78                                 {
 79                                     {1, 1, 1, 1, 1, 1, 1, 1},
 80                                     {2, 2, 2, 2, 2, 2, 2, 2},
 81                                     {3, 3, 3, 3, 3, 3, 3, 3},
 82                                     {4, 4, 4, 4, 4, 4, 4, 4},
 83                                     {5, 5, 5, 5, 5, 5, 5, 5},
 84                                     {6, 6, 6, 6, 6, 6, 6, 6},
 85                                     {6, 6, 6, 6, 6, 6, 6, 6},
 86                                     {6, 6, 6, 6, 6, 6, 6, 6}
 87                                 }
 88                     },
 89                 new Sample
 90                     {
 91                         N = 8,
 92                         M = 8,
 93                         K = 6,
 94                         Data =
 95                             new[,]
 96                                 {
 97                                     {6, 6, 6, 6, 6, 6, 6, 6},
 98                                     {6, 6, 6, 6, 6, 6, 6, 6},
 99                                     {6, 6, 6, 6, 6, 6, 6, 6},
100                                     {6, 6, 6, 6, 6, 6, 6, 6},
101                                     {6, 6, 6, 6, 6, 6, 6, 6},
102                                     {6, 6, 6, 6, 6, 6, 6, 6},
103                                     {6, 6, 6, 6, 6, 6, 6, 6},
104                                     {6, 6, 6, 6, 6, 6, 6, 6}
105                                 }
106                     },
107             };
108
109
110         private static int[] _key = {166,36,94,128,896,4096};
111
112         static void Main(string[] args)
113         {
114             var solve = new SolveGemAndPrince();
115             var solve2 = new SolveGemAndPrince2();
116             var time1 = DateTime.Now;
117             for (var i = 0; i < 10000; i++ )
118             {
119                 int t = 0;
120                 foreach (var sample in Samples)
121                 {
122                     var result = solve.Solve(sample.N, sample.M, sample.K, sample.Data);
123                     //var result = solve2.Solve(sample.N, sample.M, sample.K, sample.Data);
124                     //Console.WriteLine("Highest score achievable = {0}", result);
125                     if (result != _key[t++])
126                     {
127                         Console.WriteLine("error!");
128                         return;
129                     }
130                 }
131             }
132             var time2 = DateTime.Now;
133             var span = time2 - time1;
134             Console.WriteLine("Done {0}", span.TotalSeconds);
135         }
136     }
137 }

将工程编译都调整到速度最大优化，编译环境为Visual Studio 2012，C++编译为32位，C#为Any CPU，运行于CORE i7。结果是运行10000次循环，算法相同的C++程序的速度大约是C#的6倍。当然这个倍率有点高于我的预料，可能程序中还有需要对针对C#进行改进和优化的地方（例如减少堆分配等），但同样C++也有提升空间（当然原作者已经做的很好了）。这个程序包含栈/递归和字典数据结构和一些逻辑和计算操作。总的来说在最大速度优先编译情况下，C++相对C#的执行效率优势还是比较明显。等过一阵子有空针对这个实例再做一次review和各自优化再评估一下结果。

关于效率这个问题，stackoverflow上有一些讨论可以参考：

http://stackoverflow.com/questions/145110/c-performance-vs-java-c

http://stackoverflow.com/questions/3961426/c-sharp-vs-c-performance-comparison

附，对应的C++程序（由原作者所作，略作修改并用于执行效率对比）

// HDU4090cpp.cpp : Defines the entry point for the console application.
//#include "stdafx.h"#include <stdlib.h>
#include <stdio.h>
#include <map>
#include <string>
#include <string.h>
#include <time.h>using namespace std;
#define MAX 10struct node {int x,y;
}qu[MAX*MAX];map<string,int> _hash;
int gmmap[8][MAX][MAX];
int (*mmap)[MAX];
int ans;
int n,m,K,total;
int dir[8][2] = {{1,0},{1,1},{1,-1},{-1,0},{-1,-1},{-1,1},{0,1},{0,-1}};void Print(int temp[][MAX],int n,int m) {for (int i = n-1; i >= 0; --i)for (int j = 0; j < m; ++j)printf("%d%c",temp[i][j],j==m-1?'\n':' ');
}
void change(int mmap[][MAX],int &n,int &m){int i,j,k[10],tn = 0,tm = 0;for (j = 0; j < m; ++j) {k[j] = 0;for (i = 0; i < n; ++i)if (mmap[i][j]) mmap[k[j]++][j] = mmap[i][j];}for (j = 0; j < m; ++j) if (k[j]) {for (i = 0; i < k[j]; ++i)mmap[i][tm] = mmap[i][j];for (i = k[j]; i < n; ++i)mmap[i][tm] = 0;tm++;if (k[j] > tn) tn = k[j];}n = tn,m = tm;
}
int Ok(int temp[][MAX],int vis[][MAX],int i,int j,int n,int m) {int cnt = 0,k;int head = 0,tail = 0;node cur,next;cur.x = i,cur.y = j;qu[head++] = cur;vis[cur.x][cur.y] = 1;while (tail < head) {cur = qu[tail++];cnt++;for (k = 0; k < 8; ++k) {next.x = cur.x + dir[k][0];next.y = cur.y + dir[k][1];if (next.x >= 0 && next.x < n&& next.y >= 0 && next.y < m&& vis[next.x][next.y] == 0&& temp[next.x][next.y] == temp[i][j]) {qu[head++] = next;vis[next.x][next.y] = 1;temp[next.x][next.y] = 0;}}}temp[i][j] = 0;return cnt >= 3 ? cnt :  0;
}
string Get_hash(int temp[][MAX],int n,int m) {string s = "";for (int i = 0; i < n; ++i)for (int j = 0; j < m; ++j)s += temp[i][j] + '0';return s;
}
void mem(int temp[][MAX],int mmap[][MAX],int n,int m) {memset(temp,0,sizeof(temp));for (int i = 0; i < n; ++i)for (int j = 0; j < m; ++j)temp[i][j] = mmap[i][j];
}
int Dfs(int mmap[][MAX],int n,int m) {if (n * m < 3)  return 0;int temp[MAX][MAX],i,j;int vis[MAX][MAX],cnt = 0,ans;memset(vis,0,sizeof(vis));for (i = 0; i < n; ++i)for (j = 0; j < m; ++j)if (!vis[i][j] && mmap[i][j]) {mem(temp,mmap,n,m);ans = Ok(temp,vis,i,j,n,m);if (ans >= 3) {ans = ans * ans;int tn = n,tm = m;change(temp,tn,tm);string s = Get_hash(temp,tn,tm);if (_hash.find(s) == _hash.end()) ans += Dfs(temp,tn,tm);else ans += _hash[s];if (ans > cnt) cnt = ans;}}_hash[Get_hash(mmap,n,m)] = cnt;return cnt;
}int _tmain(int argc, _TCHAR* argv[])
{int i,j,k;int key[] = {166,36,94,128,896,4096};int t=0;FILE *fp = fopen("D:\\temp\\samples.txt", "r");int testnum = 0;while (fscanf(fp, "%d%d%d",&n,&m,&K) != EOF) {for (i = n-1; i >= 0; --i)for (j = 0; j < m; ++j)fscanf(fp, "%d",&gmmap[testnum][i][j]);testnum++;}time_t t1;time(&t1);for (int C = 0; C < 10000; C++){t = 0;for (int t=0; t<testnum; t++){_hash.clear();int res = Dfs(gmmap[t],n,m);if (res != key[t]){printf("error\n");return 0;}t++;}}time_t t2;time(&t2);double diff=difftime(t2,t1);printf("done %f\n", diff);fclose(fp);
}

转载于:https://www.cnblogs.com/quanben/archive/2012/09/22/3128850.html

一个C#和C++执行效率对比的简单实例相关推荐

【Groovy】Groovy 动态语言特性 ( Groovy 语言与 Java 语言执行效率对比 | 以动态特性编译的 Groovy 类 | 以静态特性编译的 Groovy 类 )
文章目录一.以动态特性编译的 Groovy 类二.Groovy 语言与 Java 语言执行效率对比三.以静态特性编译的 Groovy 类一.以动态特性编译的 Groovy 类 Groovy 类 ...
AtomicLong与LongAdder执行效率对比
AtomicLong与LongAdder执行效率对比: package com.mashibing.juc.c_018_00_AtomicXXX;import java.util.concurrent ...
c语言读取txt到一个字符串,c语言读取txt文件内容简单实例
在C语言中,文件操作都是由库函数来完成的. 要读取一个txt文件,首先要使用文件打开函数fopen(). fopen函数用来打开一个文件,其调用的一般形式为: 文件指针名=fopen(文件名,使用文件 ...
rocketmq一个topic多个group_SpringBoot和RocketMQ的简单实例
1,引用jar包 build.gradle文件添加jar包引用 compile group: 'org.apache.rocketmq', name: 'rocketmq-spring-boot-st ...
php高效遍历,PHP 遍历数组的三种方法及效率对比分析
PHP 遍历数组的三种方法及效率对比分析本文实例分析了 PHP 遍历数组的三种方法及效率对比分享给大家供大家参考具体分析如下: 今天有个朋友问我一个问题 php 遍历数组的方法, 告诉她了几个顺便写 ...
MyBatis插入大量数据效率对比：foreach、SqlSession、sql三种方式批量插入
用mybatis插入数据执行效率对比,对比三种方式(测试数据库为MySQL), 使用 SqlSessionFactory,每一批数据执行一次提交使用mybatis-plus框架的insert方法,f ...
Python基础教程：列表推导式对比For循环执行效率
如果把1-10以内的元素追加到一个新的列表表中,如果使用for循环我们可以这么做: a = [] for i in range(1,11):a.append(i) print(a) 输出结果如下: 如 ...
python教程：列表推导式对比For循环执行效率
我们在前面的学习中都知道,如果把1-10以内的元素追加到一个新的列表表中,如果使用for循环我们可以这么做: a = [] for i in range(1,11):a.append(i) print ...
python单核运行_python下多核，单核CPU对于并行，并发执行效率的对比-Go语言中文社区...
** ** 这篇博客主要内容为python 中多线程以及多进程的效率对比,以及记录自己在做这个实验中遇到的一些问题以及心得背景引入: CPU制造商为了追求CPU效率放弃了在CPU频率上的追求(CPU ...

一个C#和C++执行效率对比的简单实例

一个C#和C++执行效率对比的简单实例相关推荐

最新文章

热门文章