<code> CODING

输出两字符串公共子串及连续公共子串的长度

 1     int LCS(string s1, string s2){//公共子序列
 2         int length1=s1.length();
 3         int length2=s2.length();
 4
 5         int **A;
 6         A=new int*[length1+1];
 7         for(int i=0;i<=length1;i++)
 8             A[i]=new int[length2+1];
 9
10         for(int i=0;i<=length1;i++)
11             A[i][0]=0;
12         for(int i=0;i<=length2;i++)
13             A[0][i]=0;
14
15         for(int i=1;i<=length1;i++)
16             for(int j=1;j<=length2;j++){
17             if(s1[i-1]==s2[j-1])
18                 A[i][j]=A[i-1][j-1]+1;
19             else{
20                 A[i][j]=max(A[i-1][j],A[i][j-1]);
21             }
22         }
23         return A[length1][length2];
24     }
25     int LCSstrict(string s1, string s2){//连续公共子串
26         int length1=s1.length();
27         int length2=s2.length();
28         int Max=INT_MIN;
29         int **A;
30         A=new int*[length1+1];
31         for(int i=0;i<=length1;i++)
32             A[i]=new int[length2+1];
33
34         for(int i=0;i<=length1;i++)
35              for(int j=0;j<=length2;j++)
36             A[i][j]=0;
37
38         for(int i=1;i<=length1;i++)
39             for(int j=1;j<=length2;j++){
40             if(s1[i-1]==s2[j-1])
41                 A[i][j]=A[i-1][j-1]+1;
42                 if(Max<A[i][j])
43                     Max=A[i][j];
44             else{
45                 A[i][j]=0;
46             }
47         }
48         return Max;
49     }

LCS, LCSstrict

快排,归并,插入,冒泡,选择排序

 1 class Solution {
 2 public:
 3     void QuickSort(vector<int> & A,int left, int right){
 4         //int b[]={1,2,4,3,5,1,4,2,6};
 5         //vector<int> a(b,b+9);
 6         //for(vector<int>::iterator iter=a.begin();iter!=a.end();iter++)cout<<*iter<<" ";
 7         if(left<right){
 8             int index=rand()%(right-left)+left;
 9
10             swap(A[left],A[index]);
11             int  i=left,j=right+1;
12             do{
13                 do i++;
14                 while(A[i]<A[left]);
15                 do j--;
16                 while(A[j]>A[left]);
17                 if(i<j)
18                 swap(A[i],A[j]);
19                 //else  break;
20             }while(i<j);
21
22              swap(A[left],A[j]);
23
24             QuickSort(A,left,j-1);
25             QuickSort(A,j+1,right);
26         }else return;
27     }
28     void MergeSort(int *A, int left,int right){
29         if(left<right){
30             int index=(left+right)/2;
31             MergeSort(A,left,index);
32             MergeSort(A,index+1,right);
33             Merge(A,left,right);
34         }else return;
35     }
36     void InsertSort(int *A, int length){
37         //把数插入到已排好序的数组中,插入位置后面数据依次后移
38         for(int i=1;i<length;i++){
39             int j=0;
40             while(A[j]<A[i]&&j<i)j++;
41             int tmp=A[j];
42             A[j]=A[i];
43             for(int x=i;x>j;x--)
44                 A[x]=A[x-1];
45         }
46     }
47     void BubbleSort(int *A, int length){
48         //相邻元素交换位置,使小值上移
49         for(int i=0;i<length--;){
50             for(int j=0;j<length;j++){
51                 if(A[j]>A[j+1])
52                     swap(A[j],A[j+1]);
53             }
54         }
55     }
56     void SelectSort(int *A , int length){
57         //选出当前数组中最值,放于相应位置
58         for(int i=0;i<length;i++){
59             int Min=A[i],index=i;
60             for(int j=i;j<length;j++){
61                 if(Min>A[j]){
62                     index=j;
63                     Min=A[j];
64                 }
65             }
66             swap(A[i],A[index]);
67         }
68     }
69  private:
70     void Merge(int *A, int left,int right){
71         int index=(left+right)/2;
72         int *B=new int[index-left+1];
73         int *C=new int[right-index];
74         for(int i=0,j=left;i<index-left+1;i++,j++)
75             B[i]=A[j];
76         for(int i=0,j=index+1;i<right-index;i++,j++)
77             C[i]=A[j];
78
79         for(int i=left,x=0,y=0;i<=right;i++){
80             if((B[x]<C[y]&&(x<index-left+1))||y==right-index){
81                 A[i]=B[x];
82                 x++;
83             }else{
84                 A[i]=C[y];
85                 y++;
86             }
87         }
88             delete B,C;
89     }
90    };

排序相关源码

排列,组合

 1     void permut1 (vector<int> &A, int Start, int End, vector<vector<int> > &B){
 2         if(Start>=End){
 3             B.push_back(A);
 4         }else{
 5             for(int i=Start;i<End;i++){
 6                 swap(A[i],A[Start]);
 7                 permut1(A,Start+1, End,B);
 8                 swap(A[i],A[Start]);
 9             }
10         }
11         /*调用及输出参考
12         int b[]={1,2,3,4,5,6};
13     vector<int> A(b,b+6);
14     vector<vector<int> > B;
15     sol->permut1(A,0,A.size(),B);
16     int i=0;
17     for(vector<vector<int> >::iterator iter=B.begin();iter!=B.end();iter++){
18             cout<<++i<<" ";
19         for(vector<int>::iterator item=(*iter).begin();item!=(*iter).end();item++)
20             cout<<*item<<" ";
21         cout<<endl;
22     }
23         */
24     }
25     void permut2(vector<int> &A, int Start, int End){
26         // sol->permut2(A,0,A.size());
27         if(Start>=End){
28             for(vector<int>::iterator iter= A.begin();iter!=A.end();iter++)
29                 cout<<*iter<<" ";cout<<endl;
30         }else{
31             for(int i=Start;i<End;i++){
32                 swap(A[i],A[Start]);
33                 permut2(A,Start+1, End);
34                 swap(A[i],A[Start]);
35             }
36         }
37     }
38     void combination(vector<int> &A){
39         int length=A.size();
40         float sum=pow(2.0,(float)length);
41         for(int i=0,x;i<sum;i++){
42             x=i;
43             for(int j=0;j<length;j++){
44                 if(x%2==1)
45                     cout<<" "<<A[length-1-j];
46                 x=x>>1;
47             }cout<<endl;
48         }
49     }
50    

Permut, combination

折半查找

 1     int binarySearch(int *A, int k,int length){
 2         //折半搜索
 3         //cout<<sol->binarySearch(b,-10,sizeof(b)/sizeof(*b))<<endl;
 4         int left=0,right=length;
 5         int index=(left+right)/2;
 6         while(index!=left&&index!=right){
 7             if(A[index]==k)
 8                 break;
 9             if(A[index]<k){
10                     left=index;
11                     index=(left+right)/2;
12             }
13             if(A[index]>k){
14                 right=index;
15                 index=(right+left)/2;
16             }
17             cout<<left<<"-"<<index<<"-"<<right<<"-"<<endl;
18         }cout<<endl;
19         if(A[index]==k)
20         return index;
21         else return -1;
22     }

BinarySearch

树的前中后续遍历

1 struct TreeNode {
2      int val;
3      TreeNode *left;
4      TreeNode *right;
5      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
6 };

 1     void PreOrderSearch(TreeNode *p){
 2         if(p){
 3             cout<<p->val<<" ";
 4             PreOrderSearch(p->left);
 5             PreOrderSearch(p->right);
 6         }
 7     }
 8     void InOrderSearch(TreeNode *p){
 9         if(p){
10             InOrderSearch(p->left);
11             cout<<p->val<<" ";
12             InOrderSearch(p->right);
13         }
14     }
15     void PostOrderSearch(TreeNode *p){
16         if(p){
17             PostOrderSearch(p->left);
18             PostOrderSearch(p->right);
19             cout<<p->val<<" ";
20         }
21     }

Tree traveler

判断相同树

 1     bool isSameTree(TreeNode *p, TreeNode *q) {
 2         if(p==NULL&&q==NULL)
 3             return true;
 4         else if((p==NULL&&q!=NULL)||(q==NULL&&p!=NULL)||(p->val!=q->val))
 5             return false;
 6         if(p->val==q->val)
 7         return isSameTree(p->left,q->left)&&isSameTree(p->right,q->right);
 8
 9     }
10  

SameTree

判断链表有环

1 struct ListNode{
2     int val;
3     ListNode* next;
4 };

 1     bool hasCycle(ListNode *head) {
 2         ListNode * p1=head;
 3         ListNode * p2=head;
 4         while(p1!=NULL&&p2!=NULL&&p2->next!=NULL){
 5             p1=p1->next;
 6             p2=p2->next->next;
 7             if(p1==p2)
 8                 return true;
 9         }
10         return false;
11     }

HasCycle

n个节点的BST树有多少种

 1     int numTrees(int n) {//BST数量
 2         int* A=new int[n+1];
 3         A[0]=1;A[1]=1;A[2]=2;
 4         for(int x=3;x<=n;x++)
 5         {
 6            A[x]=0;
 7         for(int i=0,j=x-1;i<x;i++,j--){
 8             A[x]+=A[i]*A[j];
 9         }
10         }
11         return A[n];
12     }

NumTrees

时间: 2024-11-13 08:49:35

<code> CODING的相关文章

让开发更简单 —— Coding Enterprise 发布

今天,我们很高兴地宣布 Coding Enterprise 发布了 -- Coding Enterprise 是 CODING 专为企业打造的软件开发协作平台,提供了针对中小型企业的公有云版本和针对大型企业的私有云版本,功能覆盖所有的开发场景,可以帮助企业更高效便捷地进行开发协作,真正实现一站式开发. 简单易用,安全高效 CODING 团队拥有 3 年多的互联网平台级产品开发和运营经验,旗下 Coding.net 云端软件开发协作平台已积累了 35 万多名的用户及 60 万多个项目,包括 Lin

《Cracking the Coding Interview》——第16章:线程与锁——题目5

2014-04-27 20:16 题目:假设一个类Foo有三个公有的成员方法first().second().third().请用锁的方法来控制调用行为,使得他们的执行循序总是遵从first.second.third的顺序. 解法:你应该想到了用lock的方法类阻塞,不过这里面有个概念问题使得直接用ReentrantLock不能通过编译(对于一个锁对象,不同在A线程中锁定,又在B线程中解锁,不允许这样的归属关系),可以用Semaphore来达到相同的目的.请看下面的代码. 代码: 1 // 16

《Cracking the Coding Interview》——第16章:线程与锁——题目3

2014-04-27 19:26 题目:哲学家吃饭问题,死锁问题经典模型(专门用来黑哲学家的?). 解法:死锁四条件:1. 资源互斥.2. 请求保持.3. 非抢占.4. 循环等待.所以,某砖家拿起一只筷子后如果发现没有另一只了,就必须把手里这只筷子放下,这应该是通过破坏"请求保持"原则来防止死锁产生,请求资源失败时,连自己的资源也进一步释放,然后在下一轮里继续请求,直到成功执行. 代码: 1 // This is the class for chopsticks. 2 import j

《Cracking the Coding Interview》——第16章:线程与锁——题目2

2014-04-27 19:14 题目:如何测量上下文切换的时间? 解法:首先,上下文切换是什么,一搜就知道.对于这么一个极短的时间,要测量的话,可以通过放大N倍的方法.比如:有A和B两件事,并且经常一起发生,每件只需要花几纳秒.如果你把A事件连续做几百万次,而B时间只做了几次,这样就能排除B事件对于测量的影响.如果总时间S = mA + nB.当m >> n 时,A≈S / m.下面的测量方法类似于打乒乓球,在主线程和副线程间互相传递一个令牌,这个令牌可以是变量.管道之类的用于通信的工具.与

《Cracking the Coding Interview》——第16章:线程与锁——题目1

2014-04-27 19:09 题目:线程和进程有什么区别? 解法:理论题,操作系统教材上应该有很详细的解释.我回忆了一下,写了如下几点. 代码: 1 // 16.1 What is the difference between process and thread? 2 Answer: 3 Process: 4 1. Basic element of resource allocation in the operating system. 5 2. Possesses independent

【转载】关于Python脚本开头两行的:#!/usr/bin/python和# -*- coding: utf-8 -*-的作用 &ndash; 指定文件编码类型

下面的内容来自:http://www.cnblogs.com/blueskylcc/p/5332642.html, 对方也是转的,不过没有找到转载的出处: 1.#!/usr/bin/python 是用来说明脚本语言是 python 的 是要用 /usr/bin下面的程序(工具)python,这个解释器,来解释 python 脚本,来运行 python 脚本的. 2.# -*- coding: utf-8 -*- 是用来指定文件编码为 utf-8 的 详情可以参考:PEP 0263 - Defin

Coding for Speed 技术分享

上周和公司技术同事们作了次<Coding for Speed>技术分享,本来这只是再普通不过的技术探讨和交流(虽然挂了个颇有噱头的名称),但分享的时候逻辑没理好,语速很快,时间也太紧,因此难言是合格的"分享"."探讨",所以我觉得有必要以简短的文章形式对原 PPT 作点补充,即便分享的内容很少也很简单. 本文将按原 PPT 的内容顺序分别作扩展说明或阐述,部分敏感信息将隐去,或只会简单提及. 作本技术分享的初衷,一是在工作中了解及接触了一些我个人认为可优

GitHub &amp; Bitbucket &amp; GitLab &amp; Coding 的对比分析

来源于:https://www.v2ex.com/t/313263 目前在代码托管和版本控制上的主流工具 — Git ,比较流行的服务有 Github . Bitbucket . GitLab . Coding ,他们各自有什么特点,个人使用者和开发团队又该如何选择? 在这篇文章中,我们以客观的态度,以问题作为出发点,介绍和比较 GitHub . Bitbucket . GitLab . Coding 在基本功能,开源与协作,免费与付费计划,企业解决方案,集成 flow.ci 等方面,让大家了解

Emacs 中的coding system

.title { text-align: center; margin-bottom: .2em } .subtitle { text-align: center; font-size: medium; font-weight: bold; margin-top: 0 } .todo { font-family: monospace; color: red } .done { font-family: monospace; color: green } .priority { font-fami

编程风格(Coding Style)要求

编程风格(Coding Style)要求2.1.1 文件(1) 每个模块(module)一般应存在于单独的源文件中,通常源文件名与所包含模块名相同.(2) 每个设计文件开头应包含如下注释内容:? 年份及公司名称.? 作者.? 文件名.? 所属项目.? 顶层模块.? 模块名称及其描述.? 修改纪录.2.1.2 大小写(1) 如无特别需要,模块名和信号名一律采用小写字母.(2) 为醒目起见,常数(`define定义)/参数(parameter定义)采用大写字母.2.1.3 标识符(1) 标识符采用传