Nothing Special Blog

2015년 7월 12일

[Algorithm] Edit Distance

Edit Distance 는 두 문자열을 동일하게 만들려면 얼만큼의 수정이 필요한지를 수치로 나타내는 알고리즘이다.

별로 어려운 건 없다. 핵심은 최소 수정의 값을 가져오는 DP라는 점이다.. 같은 문자가 발견되면 penalty를 없앤다. 자세한 것은 검색을 해보자. 아래는 내가 짠 기본적인 edit distance 코드다.

#include <iostream>
#include <stdio.h>
#define MIN(x,y,z) ((x) < (y)) ? ((z) < (x) ? (z) : (x)) \
: ((z) < (y) ? (z) : (y))

using namespace std;

int arr[100][100];
int strlen(char* str)
{
int cnt = 0;
while (str[cnt++] != '\0');
return cnt - 1;
}
int edit_dis(char* str1, char* str2)
{
int len1 = strlen(str1);
int len2 = strlen(str2);
for (int i = 0; i <= len1; i++) arr[i][0] = i;
for (int i = 0; i <= len2; i++) arr[0][i] = i;
for (int i = 1; i <= len1; i++){
for (int j = 1; j <= len2; j++){
int min = MIN(arr[i][j - 1] + 1, arr[i - 1][j] + 1,
(str1[i - 1] == str2[j - 1] ?
arr[i - 1][j - 1] : arr[i - 1][j - 1] + 1));
arr[i][j] = min;
}
}
return arr[len1][len2];;
}

int main()
{
char str1[100] = "monkey";
char str2[100] = "money";
int dis = edit_dis(str1, str2);
printf("%d\n", dis);
return 0;
}

2015년 7월 10일

[Algorithm] LCP

#include <iostream>
#include <stdio.h>

using namespace std;
char tstr[5005];
int idxarr[5005];
int LCP[5005];
int LEN[5005];
long long int noval;

void swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}

int strlen(char* chr)
{
int len = 0;
while(chr[len++] != '\0');
return len - 1;
}

int scmp(char ch1[], char ch2[])
{
int i = 0; int len1 = strlen(ch1);
int j = 0; int len2 = strlen(ch2);
while(i < len1 && j < len2){
if(ch1[i] < ch2[j]) return 1;
else if(ch1[i] > ch2[j]) return 0;
i++; j++;
}
return len1 < len2 ? 1 : 0;
}

void init(int n)
{
for(int i=1; i<=n; i++){
idxarr[i] = i;
LCP[i] = 0;
LEN[i] = 0;
}
noval = 0;
}

int partition(int arr[], int left, int right)
{
int low = left;
int high = right + 1;
int ppos = left;
char* pval = tstr + arr[ppos];

do{
do low++;
while (low < right && !(scmp(pval, tstr + arr[low])));
do high--;
while (left < high && (scmp(pval, tstr + arr[high])));
if(low < high) swap(arr[low],arr[high]);
}while(low < high);
swap(arr[ppos],arr[high]);
return high;
}

void sortarr(int arr[], int left, int right)
{
if(left < right) {
int pivot = partition(arr, left, right);
sortarr(arr, left, pivot - 1);
sortarr(arr, pivot + 1, right);
}
}

void makelen(int n)
{
for(int i=1; i<=n; i++)
noval += (LEN[i] = strlen(tstr + idxarr[i]));
}

void makelcp(int n)
{
for(int i=2; i<=n; i++){
int len1 = strlen(tstr + idxarr[i-1]);
int len2 = strlen(tstr + idxarr[i]);
int len = len1 < len2 ? len1 : len2;
for(int j=0; j<len; j++){
if ((tstr + idxarr[i - 1])[j] == (tstr + idxarr[i])[j])
noval -= ++LCP[i];
else break;
}
}
}

char sol[5005];
void printsol(int t, int n, int k)
{
if(noval < k){
printf("#%d none\n",t);
return;
}
int cnt = k;
int iter = 1;
while(true){
int tmp = cnt;
tmp -= (LEN[iter] - LCP[iter]);
if(tmp <= 0)
break;
cnt -= (LEN[iter] - LCP[iter]);
iter++;
}
for(int i=0; i<cnt + LCP[iter]; i++){
sol[i] = (tstr + idxarr[iter])[i];
}
sol[cnt + LCP[iter]] = '\0';
printf("#%d %s\n",t, sol);
}

int main()
{
//freopen("sample_input.txt","r",stdin);
for(int t=1; t<=40; t++){
int K; cin >> K >> (tstr + 1);
int len = strlen(tstr + 1);
init(len);
sortarr(idxarr, 1, len);
makelcp(len);
makelen(len);
printsol(t, len, K);
}
return 0;
}

2015년 7월 9일

[Algorithm] 최단 경로 알고리즘 Dijkstra, Floyd

최단 경로 문제를 푸는 흔히 쓰이는 2가지 알고리즘이 있다.

Dijkstra와 Floyd다. Dijkstra는 한 정점 s에서 다른 모든 정점 사이의 최단 거리를 구한다.

반면 Floyd 알고리즘은 모든 정점 사이의 최단 거리를 구하는 알고리즘이다. 아주 심플하면서도 강력한 최단 경로 알고리즘이다.

먼저 Dijkstra 의 코드다.

#include <iostream>
#define TRUE 1
#define FALSE 0
#define MAX_VERTICES 7
#define INF 1000
using namespace std;
int weight[MAX_VERTICES][MAX_VERTICES] =
{
{ 0, 7, INF, INF, 3, 10, INF},
{ 7, 0, 4, 10, 2, 6, INF },
{ INF, 4, 0, 2, INF, INF, INF },
{ INF, 10, 2, 0, 11, 9, 4 },
{ 3, 2, INF, 11, 0, INF, 5 },
{ 10, 6, INF, 9, INF, 0, INF },
{ INF, INF, INF, 4, 5, INF, 0 }
};
int dis[MAX_VERTICES];
int found[MAX_VERTICES];
int choose(int distance[], int n, int found[])
{
int min = INT_MAX;
int minpos = -1;
for (int i = 0; i < n; i++){
  if (distance[i] < min&&!found[i]){
   min = distance[i];
   minpos = i;
  }
}
return minpos;
};
void shortest_path(int s, int n)
{
for (int i = 0; i < n; i++){
  dis[i] = weight[s][i];
  found[i] = FALSE;
}
found[s] = TRUE;
dis[s] = 0;
for (int i = 0; i < n - 2; i++){
  int u = choose(dis, n, found);
  found[u] = TRUE;
  for (int w = 0; w < n; w++)
  if (!found[w])
  if (dis[u] + weight[u][w] < dis[w])
  {
   dis[w] = dis[u] + weight[u][w];
  }
}
}

int main()
{
shortest_path(0, MAX_VERTICES);
return 0;
}

그리고 아래는 Floyd의 코드다.

#include <iostream>
#include <stdio.h>

using namespace std;

int arr[50][50];
int main()
{
int N; cin >> N;
for (int i = 1; i <= N; i++)
for (int j = 1; j <= N; j++)
  cin >> arr[i][j];
for (int k = 1; k <= N; k++){
  for (int i = 1; i <= N; i++){
   if (i == k) continue;
   for (int j = 1; j <= N; j++){
    if (j == i || j == k) continue;
    if (arr[i][k] + arr[k][j] < arr[i][j]){
     arr[i][j] = arr[i][k] + arr[k][j];
    }
   }
  }
}
return 0;
}

2015년 7월 6일

[Data Structure] #7-1 Graph - MST (Kruskal's Method)

신장트리(Spanning Tree)는 그래프 내의 모든 정점을 포함하는 트리를 의미한다. 쉽게 말해 모든 정점이 연결되어 있어야 한다는 말이다. 만약에 N개의 정점이 있다면 N-1개의 간선만 존재하면 신장트리가 된다. 그 중에 MST(Minimum Spanning Tree)는 간선 비용의 총합이 가장 적은 트리를 의미한다.

참고로 MST 도 결국에는 Tree다. Tree는 connected acyclic graph로 모든 정점이 연결되어 있고 사이클이 없어야 한다. MST도 이러한 Tree의 특성을 물려받았다.

MST 를 구현하는 방법으로는 Kruskal 과 Prim 알고리즘이 있다. 여기서는 Kruskal만 정리한다.

Kruskal은 Sorting + Disjoint-Sets 이다.. 자세한 것은 책이나 검색을 해보자.

Kruskal's Method

#include <iostream>
#define MAX_VERTICES 100
#define INF 100

using namespace std;

int parent[MAX_VERTICES];
int num[MAX_VERTICES];

/* Union_Find */

typedef struct {
int key; // 간선의 가중치
int u; // 정점1
int v; // 정점2
} element;

void SetInit(int n)
{
for (int i = 0; i < n; i++) {
parent[i] = -1;
num[i] = 1;
}
}

int SetFind(int vertex)
{
int p, s, i;
for (i = vertex; (p = parent[i]) >= 0; i = p);
s = i; // s 는 집합의 대표 원소가 된다
for (i = vertex; (p = parent[i]) >= 0; i = p)
parent[i] = s; // 집합의 모든 원소들의 부모를 s로 설정한다
return s;
}

void SetUnion(int s1, int s2)
{
if (num[s1] < num[s2]) {
parent[s1] = s2;
num[s2] += num[s1];
}
else {
parent[s2] = s1;
num[s1] += num[s2];
}
}

/* Heap */
element h[10000];
int hsize;

void Init()
{
hsize = 0;
}

void Insert(element item)
{
int i = ++hsize;
while ((i != 1) && item.key < h[i / 2].key)
{
h[i] = h[i / 2];
i /= 2;
}
h[i] = item;
}

element Remove()
{
int p, c;
element item = h[1];
element temp = h[hsize--];
p = 1;
c = 2;
while (c <= hsize)
{
if (c < hsize && h[c].key > h[c + 1].key) c++;
if (temp.key <= h[c].key) break;
h[p] = h[c];
p = c;
c *= 2;
}
h[p] = temp;
return item;
}

void InsertHeapEdge(int u, int v, int weight)
{
element e;
e.u = u;
e.v = v;
e.key = weight;
Insert(e);
}

void InsertAllEdge()
{
InsertHeapEdge(0, 1, 29);
InsertHeapEdge(1, 2, 16);
InsertHeapEdge(2, 3, 12);
InsertHeapEdge(3, 4, 22);
InsertHeapEdge(4, 5, 27);
InsertHeapEdge(5, 0, 10);
InsertHeapEdge(6, 1, 15);
InsertHeapEdge(6, 3, 18);
InsertHeapEdge(6, 4, 25);
}

void Kruskal(int n)
{
int edge_accepted = 0; // 현재까지 선택된 간선의 수
int uset, vset; // 정점 u와 정점 v의 집합 번호
element e;

Init();
InsertAllEdge();
SetInit(n);
while (edge_accepted < (n - 1))
{
e = Remove();
uset = SetFind(e.u);
vset = SetFind(e.v);
if (uset != vset) {
printf("(%d,%d) %d \n", e.u, e.v, e.key);
edge_accepted++;
SetUnion(uset, vset);
}
}
}

int main()
{
Kruskal(7);
return 0;
}

[Algorithm] Quick Sorting

퀵소트는 알고리즘 문제를 풀 때 가장 현실적이면서도 가장 빠른 성능의 정렬 알고리즘이다. 가장 쉬운 구현 방법을 여기에 적어둔다. 내림차순으로 정렬한다.

#include <iostream>

#include <cstdio>

using namespace std;

void Swap(int &a, int &b)

{

    int temp = a;

    a = b;

    b = temp;

}

int Partition(int *list, int left, int right)

{

    int low = left;

    int high = right + 1;

    int ppos = left;

    int pval = list[ppos];

do{

        do low++;

        while(low <= right && list[low] > pval);

        do high--;

        while(high >= left && list[high] < pval);

        if(low < high){

            Swap(list[low],list[high]);

            for (int i = 0; i < 5; i++)

                printf("%d ",list[i]);

            printf("\n");

}

     }while(low < high);

    Swap(list[ppos], list[high]);

    return high;

}

void QuickSort(int *list, int left, int right)

{

    if (left < right) {

        int pivot = Partition(list, left, right);

        QuickSort(list, left, pivot - 1);

        QuickSort(list, pivot + 1, right);

}

}

int arr[5] = {5,2,1,6,3};

int main (int argc, char *argv[])

{

    setbuf(stdout, NULL);

    QuickSort(arr, 0, 4);

    for (int i=0; i<5; i++) {

        printf("%d ",arr[i]);

}

    printf("\n");

    return 0;

}

2015년 7월 1일

[Algorithm] Bit 연산

1 << n

2의 n승을 의미함. 예를 들어 n = 3 이면, 1 << 3 = 8 = 2의 3승!

{1,2,3}의 모든 부분 집합의 개수를 의미하기도 함.

{ }, {1}, {2}, {3}, {1,2}, {1,3}, {2,3}, {1,2,3} 은 8 = 2의 3승개이다.
자세한 것은 http://karmainearth.tistory.com/150

i & (1 << j)

i의 j번째 bit가 1인지를 검사한다.

이를 이용해 모든 부분집합의 수를 출력해 볼 수 있다. 코드는 다음과 같다.

#include <iostream>

using namespace std;

int arr[3] = 

{

    1,2,3

};

void makeCandidates(int n)

{

    int k = (1 << n); 

    for(int i=0; i<k; i++)

{

        printf("{");

        for(int j=0; j<n; j++)

        if(i & (1 << j)) printf("%d",arr[j]);

        printf("}\n");

}

}

int main()

{

    makeCandidates(3);

    return 0;

}

Result

{}

{1}

{2}

{12}                                                             

{3}

{13}                                                             

{23}                                                             

{123}

집합 {1,2,3} 의 모든 부분 집합을 출력 했다. 이를 이용해 완전 검색 문제를 해결할 수도 있을 것이라 예상된다..

2015년 6월 29일

[Ubuntu] Vim 환경설정

꽤나 쓸만한 Vim 환경을 구축해 드릴게요 ㅎㅎㅎㅎㅎ

- vim 및 몇 가지 설치
$ sudo apt-get install vim
$ sudo apt-get install vim-gtk // Ctrl C+V 를 가능하게 해줌
$ sudo apt-get install g++ // Build 를 할수 있게 해줌

- vim 환경설정
본 래 Vim에 접속할때마다 환경설정을 해줘야합니다. 하지만 Vim이 실행될 때마다 실행되는 파일이 몇가지 있습니다. 대표적으로 ~/.vimrc가 있죠. 물론 전역으로 하고 싶다면 etc/vim/vimrc 혹은 /etc/vim/vimrc 중에 존재 하는 파일을 아래와 같이 수정하면 됩니다.
(참고 : http://vim.cybermirror.org/runtime/mswin.vim)

///////////////////////////////////////////////////여기서부터 ~/.vimrc 에 붙여넣기를 합니다.

set showcmd " Show (partial) command in status line.
set showmatch " Show matching brackets.
set ignorecase " Do case insensitive matching
set smartcase " Do smart case matching
set incsearch " Incremental search
set autowrite " Automatically save before commands like :next and :make
set hidden " Hide buffers when they are abandoned
set mouse=a " Enable mouse usage (all modes)

set nu
set cindent
set autoindent
set smartindent

set ts=4
set shiftwidth=4
"set visualbell

set background=dark
colorscheme evening

set nocompatible
set complete
"set backspace=start,indent

" Mapping shift + arrow key to move line up/down
nnoremap <S-Up> :m-2<CR>
nnoremap <S-Down> :m+<CR>
inoremap <S-Up> <Esc>:m-2<CR>
inoremap <S-Down> <Esc>:m+<CR>

" copy and paste
vmap <C-c> "+yi
vmap <C-x> "+c
vmap <C-v> c<ESC>"+p
imap <C-v> <ESC>"+pa

" Highlight matches without moving
let g:highlighting = 0
function! Highlighting()
if g:highlighting == 1 && @/ =~ '^\\<'.expand('<cword>').'\\>$'
let g:highlighting = 0
return ":silent nohlsearch\<CR>"
endif
let @/ = '\<'.expand('<cword>').'\>'
let g:highlighting = 1
return ":silent set hlsearch\<CR>"
endfunction
nnoremap <silent> <expr> <CR> Highlighting()

" Pathogen
execute pathogen#infect()
syntax on
filetype on
filetype plugin indent on

" NERD Tree
let NERDChrismastree = 1
let NERDTreeMouseMode = 2

map <F7> :NERDTreeToggle ./<CR>

" NERD Commenter
let NERDSpaceDelims=1

" Tag List
let Tlist_Auto_Highlight_Tag = 1
let Tlist_Auto_Update = 1
"let Tlist_Close_On_Select = 1
let Tlist_Display_Tag_Scope = 1 "함수 원형 표시
let Tlist_Exit_OnlyWindow = 1
let Tlist_Show_One_File = 1
let Tlist_Sort_Type = "name"
let Tlist_Use_Right_Window = 1
let Tlist_Use_SingleClick = 1
let Tlist_WinWidth = 40
map <F8> :Tlist<CR>

set tags+=[tag directory]/tags "ctags 태그 정보 부름

" Build
if !filereadable(expand("%:p:h")."/Makefile")
setlocal makeprg=g++\ -o\ %<\ %
endif
map <F9> :w<CR> :make!<CR> :cw<CR>
map <F10> :QuickRun<CR>

" cscope
set csprg=/usr/bin/cscope
set csto=0 "숫자 0
" set cst
set nocsverb
if filereadable("./cscope.out")
cs add cscope.out
else
cs add ~/git/weather/cscope.out
endif
set csverb

nmap <C-\>s :cs find s <C-R>=expand("<cword>")<CR><CR>

" vim-scrollbar
map <leader>sb :call ToggleScrollbar()<cr>

" mswin
source ~/.vim/bundle/mswin/mswin.vim

" airline
let g:airline#extensions#tabline#enabled = 1 "tab 기능 추가

" Fswitch
nnoremap <Leader>f<Space> :FSHere<CR>
nnoremap <Leader>fr :FSSplitRight<CR>

" color scheme
let g:solarized_termcolors=256
set background=dark
colorscheme solarize

/////////////////////////////////////////////////////////여기까지 복사하시면 됩니다.

- Plugin 설치

하나하나 설치를 해보죠. (맥에서는 brew를 먼저 설치한다. 중간에 CMake 설치가 필요할수도 있다)

1) Pathogen : Plugin을 관리하는 플러그인입니다. 아래의 링크를 참고해서 설치해주세요.

http://www.vim.org/scripts/script.php?script_id=2332
사용법 :http://addisu.taddese.com/blog/using-github-and-pathogen-for-your-vim-config-files/

2) YouCompleteMe : 자동완성 기능의 플러그인 입니다. 다음의 명령어로 심플하게 설치할 수 있습니다.

apt-get install vim apt-get install vim-youcompleteme apt-get install vim-addon-manager vam install youcompleteme

#참고
http://weichong78.blogspot.kr/2014/06/vim-to-ubuntu-1404-youcompleteme.html

http://stackoverflow.com/questions/16495609/pathogen-is-not-executed-when-i-am-starting-vim-on-ubuntu-12-10

http://www.alexeyshmalko.com/2014/youcompleteme-ultimate-autocomplete-plugin-for-vim/

3) TagList : 파일에 있는 변수와 함수를 잘 정리해서 보여 주는 플러그인입니다. 단축키 F8입니다. 아래의 링크를 참조해서 설치해주세요.
http://onestepcloser.tistory.com/60
설치 방법 : http://englanders.us/~jason/howtos.php?howto=ctags

4) NERDTree : F7로 맵핑된 플러그인입니다. 마치 이클립스의 Project Explorer 처럼 디렉토리와 파일을 보여줍니다. Ctrl+W+방향키 단축키로 트리와 소스를 왔다갔다 할 수 있습니다.

5) NERD Commenter : 주석처리를 편하게 해주는 플러그인 입니다.
단축키 '\ + c + spacebar' 로 주석을 하거나 풀수 있습니다. 스페이스 바 눌리는 거 잊지마세요.

6) QuickRun : F9(빌드) + F10(실행) 으로 맵핑되어 있습니다. 간편한 키 설정으로 아웃풋을 즉각적으로 볼 수 있습니다.

7) Vim-scrollbar : Vim에서 스크롤바를 생성합니다. \ + s + b 로 on/off 가능.

ref : https://github.com/lornix/vim-scrollbar

8) Mswin : 윈도우처럼 Ctrl x, Ctrl v, Ctrl c 등등이 가능하게 해주는 플러그인입니다.
ref : http://vim.cybermirror.org/runtime/mswin.vim

9) CtrlP : Sublime Text 와 같은 검색 기능입니다. Ctrl+P 를 눌러 파일을 검색할 수 있게 해줍니다.
#다운로드 : http://kien.github.io/ctrlp.vim/
#참고 : http://pyjamacoder.com/2013/04/25/getting-fuzzy-with-ctrlp/

10) Ack : grep 과 같은 역할을 Vim에서 더 쉽게 할 수 있게 해주는 plugin입니다.
Vim에서 사용가능한 명령어는 다음과 같습니다.
:Ack --extention [search keyword]
결과 창이 나오면 엔터를 통해 해당 줄로 이동이 가능하며 ?를 누르면 여러가지 옵션 설정을 볼 수 있습니다. ag 플러그인과 거의 동일합니다. Ack가 원조이긴 하지만.. 개인적으로는 그냥 Ag만 쓰는것도 괜찮을 것 같습니다.
shell에서 ack 라는 명령어로 사용 가능합니다.
아래의 링크에서 Ack Module을 먼저 다운로드 받은 후에 설치하면 됩니다.
#다운로드 : https://github.com/mileszs/ack.vim

11) Ag : Ack와 거의 동일합니다.. 심지어 Ack를 베껴왔다고 공식사이트에서 언급하고 있을 정도.. 그러나 Ack와도 호환이 가능하기 때문에 같이써도 무방합니다.
shell에서 ag 라는 명령어로 사용 가능합니다.
아래의 사이트에서 silversearcher-ag 를 먼저 설치하고 plugin 을 설치해야 합니다.
#다운로드 : https://github.com/rking/ag.vim

12) airline : 하단 상태바를 만들어서 Vim을 훨씬 직관적으로 보이게 합니다. 또한 탭 기능까지 있습니다.
#다운로드 : https://github.com/bling/vim-airline#automatic-truncation

13) FSwitch : cpp 와 header 파일을 손쉽게 왔다갔다 할 수 있게 해주는 플러그인 입니다.
F3 으로 맵핑 해두었습니다.
#다운로드 : https://github.com/derekwyatt/vim-fswitch

- ctags + cscopes

이 녀석들은 Plugin은 아니지만 Vim을 사용할 때 큰 도움을 주는 프로그램들입니다. 반드시 필요합니다.

1) ctags : 변수 혹은 함수의 정의/구현 부분을 찾아줍니다. 아래의 명령어로 설치합니다.

$ sudo apt-get install ctags

그리고 프로젝트 폴더로 가서 다음의 명령어로 tag 파일을 만들어줍니다.

$ ctags -R

그럼 tags 라는 폴더가 만들어질 것입니다. 이 폴더 명을 조금 전에 붙여넣기 한 ~/.vimrc의 내용 중에 [tag directory]/tags 라고 적힌 것 중 tag directory에 적어줍니다.

단축키는 다음과 같습니다.
ctrl + ] // declaration 으로 찾아간다.
ctrl + t // 본래대로 돌아간다.
:ta [var. or method name] // 해당 변수를 탐색한다.
:tn // ta에 결과의 next
:tp // ta에 결과의 prev.
:tj // 탐색 결과를 새 창에 보여주고 번호로 선택하게 함.
:sts // tj와 같으나 번호를 선택하면 그것조차 새로운 창으로 뜨게함.

2) cscopes : 해당 함수가 어디서 호출되는지를 알려줍니다. 아래의 명령어로 설치합니다.

$ sudo apt-get install cscope

다음의 /usr/bin/mkcscope.sh 파일을 만들어 다음의 내용을 추가합니다.

#!/bin/sh
rm -rf cscope.files cscope.files
find . $ -name '*.c' -o -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.s' -o -name '*.S' $ -print > cscope.files
cscope -i cscope.files

다음의 명령어로 실행권한을 주고 실행합니다.

$ sudo chmod x+ /usr/bin/mkcscope.sh

혹시 실행이 안되면 직접 명령어를 다음과 같이 타이핑합니다.

$ rm -rf cscope.files cscope.files
$ find . $ -name '*.c' -o -name '*.cpp' -o -name '*.cc' -o -name '*.h' -o -name '*.s' -o -name '*.S' $ -print > cscope.files
$ cscope -i cscope.files

마지막에 이상한 창이 나오면 ctrl+d 로 깔끔하게 무시해줍니다.

#참고

:cs find [c,d,e,f,g,i,s,t] [name]

#참고
cscope 를 제대로 작동시키려면 script 하나를 ~/.vim/plugin 폴더에 넣어줘야한다.
http://cscope.sourceforge.net/cscope_maps.vim

#참고
https://ysoh.wordpress.com/2012/04/09/%EB%A6%AC%EB%88%85%EC%8A%A4-%EC%BB%A4%EB%84%90-%EA%B0%9C%EB%B0%9C%EC%9D%84-%EC%9C%84%ED%95%9C-vim-%EC%84%A4%EC%A0%95-vimrc/

http://csl.skku.edu/uploads/SSE3044F12/vim_ctags_cscope.pdf

- Color Scheme 설치

가장 예쁘다고 소문이 자자한 Solarized를 사용해봅시다. 다음의 링크에서 Zip 파일을 다운로드 합니다.

https://github.com/altercation/vim-colors-solarized

해당 폴더를 ~/.vim/bundle 에 넣으면 끝

p.s. terminator같은 터미널을 사용하면 컬러가 제대로 동작하지 않을 가능성이 있다. 그럴 때는 ~/.bashrc 에 다음 명령어를 적어준다

export TERM=xterm-256color