├── prime-number-sieve-algorithm.cpp
├── longest-decreasing-subsequence-o(n2).cpp
├── longest-increasing-subsequence-o(n2).cpp
└── depth-first-search-algorithm.cpp


/prime-number-sieve-algorithm.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<vector>
 4 | #define M 1234567
 5 | using namespace std;
 6 | 
 7 | int prime[M+1]={0};
 8 | vector<int>primeNumber;
 9 | 
10 | void primeGen(){
11 |     for(int i=2; i<M; i++){
12 |         if(prime[i]==0){
13 |             prime[i]=-1;
14 |             primeNumber.push_back(i);
15 |             for(int j=i+i; j<M; j=i+j){
16 |                 prime[j]=j;
17 |             }
18 |         }
19 |     }
20 | }
21 | 
22 | int main(){
23 |     primeGen();
24 |     //for(int i=0; i<10; i++) cout << primeNumber[i] << endl;
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/longest-decreasing-subsequence-o(n2).cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int main(){
 7 |     int n;
 8 |     cin >> n;
 9 |     int data[n];
10 |     for(int i=0; i<n; i++){
11 |         cin >> data[i];
12 |     }
13 |     // count longest sequence
14 |     int lis[n]={1};
15 |     for(int i=0; i<n; i++){
16 |         for(int j=0; j<n; j++){
17 |             if(data[j]>data[i]){
18 |                 if(lis[i]<lis[j]+1){
19 |                     lis[i]=lis[j]+1;
20 |                 }
21 |             }
22 |         }
23 |     }
24 |     // printing the longest increasing subsequence size/length
25 |     cout << *max_element(lis, lis+n) << endl;
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/longest-increasing-subsequence-o(n2).cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<algorithm>
 3 | 
 4 | using namespace std;
 5 | 
 6 | int main(){
 7 |     int n;
 8 |     cin >> n;
 9 |     int data[n];
10 |     for(int i=0; i<n; i++){
11 |         cin >> data[i];
12 |     }
13 |     // count longest sequence
14 |     int lis[n]={1};
15 |     for(int i=0; i<n; i++){
16 |         for(int j=0; j<n; j++){
17 |             if(data[j]<data[i]){
18 |                 if(lis[i]<lis[j]+1){
19 |                     lis[i]=lis[j]+1;
20 |                 }
21 |             }
22 |         }
23 |     }
24 |     // printing the longest increasing subsequence size/length
25 |     cout << *max_element(lis, lis+n) << endl;
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/depth-first-search-algorithm.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<cstring>
 3 | #include<vector>
 4 | 
 5 | using namespace std;
 6 | 
 7 | int vertex; // vertex / node of the graph
 8 | int edge; // edge / connection of the graph
 9 | vector<int>sequence;
10 | int startingNode; // starting node to traverse the graph
11 | vector<int>graph[100]; // graph to traverse
12 | bool visited[100] = {false}; // checking the node has been visited or not
13 | 
14 | void inputGraphData(int a, int b){
15 |     graph[a].push_back(b);
16 | }
17 | 
18 | void createGraph(){
19 |     int a; // source
20 |     int b; // destination
21 |     while(edge--){
22 |         cin >> a >> b;
23 |         inputGraphData(a, b);
24 |     }
25 | }
26 | 
27 | void dfs(int startingNode){
28 |     visited[startingNode]=true;
29 |     sequence.push_back(startingNode);
30 |     for(int i=0; i<graph[startingNode].size(); i++){
31 |         //cout << graph[startingNode-1][i] << endl;
32 |         if(!visited[graph[startingNode][i]]){
33 |             dfs(graph[startingNode][i]);
34 |             //cout << graph[startingNode][i] << endl;
35 |             //cout << "working" << graph[startingNode-1][0] << endl;
36 |         }
37 |     }
38 | }
39 | 
40 | void displaySequence(){
41 |     for(int i=0; i<sequence.size(); i++){
42 |         cout << sequence[i] << endl;
43 |     }
44 | }
45 | 
46 | void displayGraph(){
47 |     for(int i=0; i<vertex; i++){
48 |         for(int j=0; j<graph[i].size(); j++){
49 |             cout << graph[i][j] << " ";
50 |         }
51 |         cout << endl;
52 |     }
53 | }
54 | 
55 | int main(){
56 |     cin >> vertex; // taking the number of node
57 |     cin >> edge; // taking the number of connection
58 |     createGraph();
59 |     //displayGraph(); // just for checking that 2d vector is working
60 |     //cin >> startingNode;
61 |     dfs(1);
62 |     //cout << sequence.size() << endl;
63 |     displaySequence();
64 |     //for(int i=0; i<vertex; i++) cout << visited[i] << endl;
65 |     return 0;
66 | }
67 | 


--------------------------------------------------------------------------------