C++博客-snail-文章分类-算法

c++算法入门题 3

walking snail — Mon, 13 Apr 2009 03:21:00 GMT

1 /*
2 3. 打印一个 N*N 的方阵，Ｎ为每边           Ｎ＝１５  打印出下面图形
3  字符的个数（３＜Ｎ＜２０）, 要求最               TTTTTTTTTTTTTTT
4  外一层为"T", 第二层为"J", 从第三层               TJJJJJJJJJJJJJT
5  起每层依次打印数字 1,2,3,                     TJ11111111111JT
6  （右图以Ｎ为１５为例）                           TJ12222222221JT
7                                                   TJ12333333321JT
8                                                   TJ12344444321JT
9                                                   TJ12345554321JT
10                                                   TJ12345654321JT
11                                                   TJ12345554321JT
12                                                   TJ12344444321JT
13                                                   TJ12333333321JT
14                                                   TJ12222222221JT
15                                                   TJ11111111111JT
16                                                   TJJJJJJJJJJJJJT
17                                                   TTTTTTTTTTTTTTT
18
19
20 */
21
22
23
24 #include <iostream>
25 #include <cstdlib>
26 #include <cmath>
27
28 using namespace std;
29
30 int CurrentCharToDraw(int i, int j);
31 int N = 0;
32 void main()
33 {
34     int currentItem = 0;
35     cout << "input value for N( 3 < N < 20):\n";
36     cin >> N;
37     for (int i = 0; i < N; i++)
38     {
39         for (int j = 0; j < N; j++)
40         {
41             currentItem = CurrentCharToDraw(i, j);
42             if (currentItem > 0)
43             {
44                 cout << currentItem;
45             } else {
46                 if (currentItem == -1)
47                 {
48                     cout << "J"; // -1
49                 } else { /// -2
50                     cout << "T";
51                 }
52             }
53         }
54         cout << '\n';
55     }
56 }
57
58 int CurrentCharToDraw(int i, int j)
59 {
60     int currentItem = 0;
61     int currentDistance = 0;
62     int distanceToH = 0;
63     int distanceToV = 0;
64     distanceToH = i < N - 1 - i ? i : N - 1 - i;
65     distanceToV = j < N - 1 - j ? j : N - 1 - j;
66     currentDistance = distanceToH < distanceToV ? distanceToH : distanceToV;
67     if (currentDistance < 2 )//(abs(i - N) < 2 || i < 2)
68     {
69         currentItem = currentDistance - 2;
70     } else {
71         currentItem = currentDistance - 1;
72     }
73     return currentItem;
74 }

walking snail 2009-04-13 11:21 发表评论

c++算法入门题 6

walking snail — Sun, 12 Apr 2009 14:28:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 /* 2 6. 矩阵中填数. 当给出 N*N 的矩阵，要求用程序填入下列形式的数： ... 阅读全文

walking snail 2009-04-12 22:28 发表评论

c++算法入门题 5

walking snail — Sun, 12 Apr 2009 14:21:00 GMT

1 /*
2  5. 输入一个十进数，将其转换成 N 进制数（0 3  */
4
5 #include <iostream>
6 #include <cmath>
7
8 using namespace std;
9
10 int N = 0;
11 int num = 0;
12 int* tranlateIntoN(int num);
13 void main()
14 {
15 loop:
16     cout << "input value for N:";
17     cin >> N;
18     cout << "\ninput value for num:";
19     cin >> num;
20     int Nvalue[16];
21     int i=0;
22     //Nvalue = tranlateIntoN(num);
23     Nvalue[0] = num % N;
24     //cout << Nvalue[0];
25     i++;
26     while ( num / N != 0)
27     {
28         num = num / N;
29         Nvalue[i] = num % N;
30         //cout << Nvalue[i];
31         i++;
32     }
33     while(i > 0)
34     {
35         --i;
36         if (Nvalue[i] > 10)
37         {
38             char base = 'A';
39             cout << char(base + Nvalue[i] - 10);
40         }else {
41             cout << Nvalue[i];
42         }
43
44     }
45     cout << "\ntry again?(y/n)";
46     char answer;
47     cin >> answer;
48     if (answer == 'y' || answer == 'Y')
49     {
50         goto loop;
51     }
52     cout << '\n';
53
54
55 }
56 /*
57 int* tranlateIntoN(int num)
58 {
59     int Nvalue[];
60     return Nvalue;
61 }
62 */

walking snail 2009-04-12 22:21 发表评论

c++算法入门题 4

walking snail — Sun, 12 Apr 2009 14:16:00 GMT

1 /*
2 4. 在Ｎ行Ｎ列的数阵中, 数Ｋ（１〈＝Ｋ〈＝Ｎ）在每行和每列中出现且仅
3   出现一次，这样的数阵叫Ｎ阶拉丁方阵。例如下图就是一个五阶拉丁方阵。
4   编一程序，从键盘输入Ｎ值后，打印出所有不同的Ｎ阶拉丁方阵，并统计个数。
5
6         1  2  3  4  5
7         2  3  4  5  1
8         3  4  5  1  2
9         4  5  1  2  3
10         5  1  2  3  4
11 */
12 #include <iostream>
13 #include <cmath>
14
15 using namespace std;
16
17 int N = 3;
18
19 void main()
20 {
21     int n_temp;
22 //     cout << "input the value for N:";
23 //     cin >> n_temp;
24 //     cout << '\n';
25     int matrix[3][3];
26     int row[3];
27     int col[3];
28     int numOfMatrix = 0;
29     int currentItem = 0;
30     for (int k=0; k < N; k++)
31     {
32         matrix[0][0] = k+1;
33         row
34         for (int i = 0; i < N; i++)
35         {
36             for (int j = 0; j < N; j++)
37             {
38                 if ( i == j == 0 )
39                 {
40                     continue;
41                 }
42
43
44             }
45         }
46     }
47 }

walking snail 2009-04-12 22:16 发表评论

排列、组合、集合 3.1

walking snail — Thu, 20 Nov 2008 09:43:00 GMT

列出{1，2，3，4，。。。n}这个集合的所有子集，包括空集

1
2 #include <iostream>
3 #include <bitset>
4
5 using namespace std;
6
7 const int num_item = 5;
8 /// a = {1,2,3};
9 void printAllSets(unsigned long value);
10 int GetCurrentItem(int index);
11
12 void main()
13 {
14     bitset<num_item> sets;
15     sets.set();
16     long numOfSets = sets.to_ulong();
17     //sets.reset();
18     for(; numOfSets >= 0; numOfSets--)
19     {
20         printAllSets(numOfSets); // print current set which contains i items!
21     }
22 }
23
24 void printAllSets(unsigned long value)  ///the sets contains numOfItem items
25 {
26     ///sum  num_item
27     bitset<num_item> sets(value);
28     unsigned long itemCount = sets.count();
29     cout << "{ ";
30
31     for(unsigned int i = 0; i < sets.size(); i++)
32     {
33         if(sets.test(i))
34         {
35             cout << i + 1;
36             if(0 < --itemCount)
37             {
38                 cout << ",";
39             }
40         }
41     }
42     cout << " }";
43     cout << "\n";
44 }
45
46 int GetCurrentItem(int index)
47 {
48     return index;
49 }

walking snail 2008-11-20 17:43 发表评论

排列、组合、集合 3.3

walking snail — Thu, 20 Nov 2008 08:27:00 GMT

3.3 用Gray码的顺序列出一个集合的所有子集
///gary 码就是相邻两个集合中的元素里，只有一个不同。如0001 0011

  1 // Question3_3.cpp : Defines the entry point for the console application.
  2 //
  3
  4 #include <iostream>
  5 #include <bitset>
  6 #include <cmath>
  7 #include <stack>
  8
  9 //#include "stdafx.h"
10 using namespace std;
11
12 const int bitNum = 4;
13 int temp = 16;
14 const int setNum = 16; //pow(2, bitNum);
15
16 struct itemData
17 {
18     bitset<bitNum> item;
19     int child;
20 };
21
22 int getChildNum(bitset<bitNum> curState, bitset<setNum> setTag);
23 bitset<bitNum> getChildIndex(bitset<bitNum> curState, bitset<setNum> setTag, int child);
24
25 void main(void)
26 {
27     itemData curData;
28     stack<itemData> states;
29     bitset<bitNum> curState;
30     bitset<setNum> setTag;
31
32     setTag.set(); // 1111111..   means the states can be used
33     curState.reset(); // initialize as 000000. this is the scratch line
34     setTag.reset(curState.to_ulong());  // 0: used 1:unused
35     curData.child = getChildNum(curState, setTag);
36     curData.item = curState;
37     states.push(curData);
38
39     int child;
40     while(setTag.to_ulong() != 0) // not ended
41     {
42         curData = states.top();
43         child = curData.child;
44         curState = curData.item;
45         if( child == 0 )
46         {
47             states.pop();
48             setTag.set(curData.item.to_ulong()); //set this state be unused
49         } else {
50             curData.child--;
51             states.pop();
52             states.push(curData);
53             curState = getChildIndex(curState, setTag, child);
54             setTag.reset(curState.to_ulong()); // set this state be used
55
56             curData.child = getChildNum(curState, setTag);
57             curData.item = curState;
58             states.push(curData);
59         }
60     }
61     int total = 0;
62     while(!states.empty())
63     {
64         cout << states.top().item << "\n";
65         total++;
66         states.pop();
67     }
68     cout << total <<" right?\n";
69 }
70
71 int getChildNum(bitset<bitNum> curState, bitset<setNum> setTag)
72 {
73     bitset<bitNum> temp;
74     int child = 0;
75     for(int i = 0; i < curState.size(); i++)
76     {
77         temp = curState;
78         temp.flip(i);
79         if(setTag.test(temp.to_ulong()))
80         {
81             child++;
82         }
83     }
84     return child;
85 }
86
87 bitset<bitNum> getChildIndex(bitset<bitNum> curState, bitset<setNum> setTag, int child)
88 {
89     bitset<bitNum> temp;
90     for(int i = 0; i < curState.size(); i++)
91     {
92         temp = curState;
93         temp.flip(i);
94         if(setTag.test(temp.to_ulong()))
95         {
96             child--;
97             if(child == 0)
98             {
99                 return temp;
100             }
101         }
102     }
103 }

walking snail 2008-11-20 16:27 发表评论

排列、组合、集合3.2

walking snail — Thu, 20 Nov 2008 08:22:00 GMT

3.2 用字典顺序把一个集合的所有子集都找出来

1 #include <iostream>
2 #include <bitset>
3 #include <stack>
4
5 using namespace std;
6
7 const int num_item = 5;
8 /// a = {1,2,3};
9 struct dataEncapsule
10 {
11     int item;
12     int childNum;
13 };
14
15 void printAllSets(stack<dataEncapsule> items);
16 void printRecursive(stack<dataEncapsule> items);
17
18 void main()
19 {
20     stack<dataEncapsule> items;
21     dataEncapsule currentItem;
22     for(int i = 0; i < num_item; i++)
23     {
24         currentItem.item = i;
25         currentItem.childNum = num_item - currentItem.item - 1;
26         items.push(currentItem);
27         printAllSets(items);
28         while(!items.empty())
29         {
30             currentItem = items.top();
31             if(currentItem.childNum == 0)
32             {
33                 items.pop();
34             } else {
35                 currentItem.childNum--;
36                 items.pop();
37                 items.push(currentItem);
38                 currentItem.item = num_item - currentItem.childNum - 1;
39                 currentItem.childNum = num_item - currentItem.item - 1;
40                 items.push(currentItem);
41                 printAllSets(items);
42             }
43         }
44     }
45     cout << "is my answer right?\n";
46
47 }
48
49 void printAllSets(stack<dataEncapsule> items)
50 {
51     ///sum  num_item
52     cout << "{ ";
53         printRecursive(items);
54     cout << " }";
55     cout << "\n";
56 }
57
58 void printRecursive(stack<dataEncapsule> items)
59 {
60     if(items.empty())
61     {
62         return;
63     }
64     dataEncapsule item = items.top();
65     items.pop();
66     printRecursive(items);
67     if(!items.empty())
68     {
69         cout << ",";
70     }
71     cout << item.item + 1;
72 }

walking snail 2008-11-20 16:22 发表评论