#include <iostream>
#include <iomanip>

using namespace std;

class Dikstra
{
public :
Dikstra(int);
void input(); // 인접-행렬 입력 및 생성
void ShortestPath(const int n, const int v); // 빠른길로 가중치를 갱신
int choose(int); // 시작~목적지 까지의 누적 길이가 가장 적은 정점을 반환
void print_route(int i , int u); // 누적 길이를 출력
void result(int v,int end); // 최종 목적지까지의 최종 경로 출력
private:
int length; // 배열의 최대길이
int **matrix; // 인접-행렬
bool *check_route; // 중복체크 배열
int *previous; // 역추적을 위한 배열
int *dist; // 거리 누적 배열
};




Dikstra::Dikstra(int n)
{
length = n;
// N 크기 배열 생성(갔던길 중복 방지를 위해)
check_route = new bool[length];
// 최단 경로의 길이 저장을 위한 배열
dist = new int[length];
// 최단경로의 역추적을 위해
previous = new int[length];
// N by N 배열 생성
matrix = new int*[length];
for(int i=0; i<length; i++)
{
matrix[i] = new int[length];
previous[i] = -1;
}
}




void Dikstra::input()
{
char ch;
int weight=0; // 가중치
int row=0 , column=0; // 행,렬
cout <<"[ 1~5000 사이의 가중치를 입력하되, 연결이 안되어있으면 '9999' 을 입력 ]" << endl;
for(row = 0 ; row < length ; row++)
{
for(column = 0 ; column < length ; column++)
{
if(column != row)
{
cout<<" vertex "<< row << " -> "<< column << " 으로의 가중치를 입력하세요 ";

while(1)
{
try
{
cout << "입력 : ";
cin >> weight;
cin.get(ch);

if( cin.fail() || isalpha(ch) || ispunct(ch) )
{
throw "정수입력에러";
cout << weight << endl;
}
else break;
}
catch(char *error)
{
cin.clear();
while((ch = cin.get()!='\n') && ch != EOF);
cout << error << endl;
continue;;

}
}
matrix[row][column] = weight;
}
if(column == row) matrix[row][column] = 0;
}
}
cout << "행렬 완성 " << endl << endl;
}





void Dikstra::ShortestPath(const int n, const int v)
{

// dist[j] (0 <= j < n) 는 v에서 j까지의 최단 경로의 길이이다.
// 간선의 길이는 matrix[i][j]의 값 이다.

for(int i = 0 ; i < n ; i++)
{// 초기화
check_route[i] = false;
dist[i] = matrix[v][i];
}
check_route[v] = true; // 시작점은 바로 S에 속해짐
dist[v] = 0 ; // 자신까지의 거리 = 0

cout<< "=======================================================================" << endl;
cout << setw(5) << "반복|" ;
cout << setw(5) << "선택정점|";

for(int i = 0 ; i < n ; i++)
cout << setw(5)<< " dist[" << i << "] ";
cout << endl;

int u = -1;
// 정점 v에서 부터의 n-1 경로를 설정
for(int i = 0 ; i < n - 2 ; i++)
{
print_route(i,u);
u = choose(n); // choose 는 check_route[w] = false 이고,
// dist[u] = minimum dist[w] 가 되는 u를 반환
check_route[u] = true;
// ====== 최단거리로 갱신 =======//
for(int w = 0; w < n ; w++)
{
if(!check_route[w] && dist[u] + matrix[u][w] < dist[w])
{
dist[w] = dist[u] + matrix[u][w];
previous[w] = u;
}

}
// ============================== //
}
}

// 누적 거리가 가장 짧은 값으로 최신화 //
int Dikstra::choose(int n)
{

int min = 9999;
int select_v = 0;
for(int w = 0 ; w < n ; w++)
{
if(check_route[w] == false && dist[w] < min)
{
select_v = w;
min = dist[w];
}
}
return select_v;
}




void Dikstra::print_route(int i, int u)
{
cout << setw(5) << i << setw(5) << u ;
for(int i = 0 ; i < length ; i++)
{

if(dist[i]==9999) cout << setw(5) <<"x";
else cout << setw(5) << dist[i];
}
cout << endl;


}

// ================= 목적지까지의 최단경로 출력 ===================
void Dikstra::result(int v,int end)
{
cout << "===================================================================================" << endl;
cout << "누적길이 : "<< dist[end] << endl;
cout <<" [최단경로]" << endl;
cout << "도착(" << end <<") <---------------------------- " << "시작(" << v <<")"<< endl;
cout << " ";
cout << end << " - ";
while(previous[end] != -1)
{
cout << previous[end] << " - ";
end = previous[end];
}
cout << v <<endl;

}

%{
#include
#include
enum tGrammar{TEOF, VERB, ADVERB, PREPOSITION, CONJUNCTION, ADJECTIVE, UNCONJUGATIONADJECTIVE,PRONOUN,NOUN,TDOT,SPACE,TSPOT};
%}    /* 액션코드로 C 언어 기술 시 필요한 자료 구조, 변수, 그리고
        상수 등을 정의. 렉스의 출력인 lex.yy.c의 앞부분에 복사
        치환식은 정규표현, 이름은 정규 표현의 이름 */


letter[a-zA-Z]

%%
is|am|are|were|was|be|being|been|do|does|did|will|would|should|can|could|has|have|had|go return(VERB);
very|simply|gently|quietly|really|softly|highlt|calmly|angrily|loudly return(ADVERB);
to|from|behind|in|for|with|on|above|at|between return(PREPOSITION);
if|then|and|but|so|because|or|as  return(CONJUNCTION);
their|my|you're|his|her return(ADJECTIVE);
a|the|an return(UNCONJUGATIONADJECTIVE);
I|you|he|she|we return(PRONOUN);
{letter}+ return(NOUN);
[ \t\n];
" " return(SPACE);
\. return(TDOT);
\, return(TSPOT);
%%
/*토큰 형태를 표현하는 정규 표현
인식되었을 때 처리하는 실행부분으로 C 언어로 기술*/


int main()
{
    enum tGrammar tg;
    
    printf("==========lex start==========\n");
    
    while((tg=yylex())!=TEOF)
    {
        switch(tg)
        {    
            case VERB :
                 printf("%s : VERB\n", yytext);
                 break;
                 
            case ADVERB : 
                printf("%s : ADVERB\n", yytext); 
                break;
                
            case PREPOSITION : 
                printf("%s : PREPOSITION\n", yytext); 
                break;
                
            case CONJUNCTION : 
                printf("%s : CONJUNCTION\n", yytext); 
                break;
                
            case ADJECTIVE : 
                printf("%s : ADJECTIVE\n", yytext); 
                break;
                
            case UNCONJUGATIONADJECTIVE : 
                printf("%s : UNCONJUGATIONADJECTIVE\n", yytext); 
                break;
                
            case PRONOUN : 
                printf("%s : PRONOUN\n",yytext); 
                break;
                
            case NOUN : 
                printf("%s : NOUN\n",yytext); 
                break;
                
            case TDOT : 
                printf("%s : End.\n",yytext); 
                break;
                
            case SPACE : 
                break;
            case TSPOT :
                printf("%s : SPOT.\n",yytext); 
                break;
        }

    }
    return 0;
}
int yywrap(){printf("===========lex end==========\n");
    return 1;
}    /* 실행 코드 */

import java.awt.*;
import java.awt.event.*;
import java.util.*;

// 쓰레드 클래스를 상속 받아서  run을 오버라이딩 할 것이다.
public class SimpleThread extends Thread{
 static Canvas canvas;
 int y = 0;
 String str = null;
 Random rand = new Random();
 
 public SimpleThread(int y, String str){
  this.y = y;  
  this.str = str;
 }
 
 // run은 start를 통해서 실행 된다. 현재 run은 오버라이딩 한 상태다.
 public void run(){
  Graphics g = canvas.getGraphics();
  g.drawString(str, 20, y);
  for(int i=0;i<300;i++){
   try{
    Thread.sleep(100);
    i += rand.nextInt(5);
    //각 말들은 1초 간격으로 0부터 5 까지의 랜덤한 숫자로 달리게 된다.
    
    if(i > 300){
     i = 300;
    }
    g.fillRect(50, y, i, 20);
   }catch(Exception e){
    
   }
  }
 }
 
 public static void main(String args[]){
  Frame frm = new Frame("쓰레드 테스트");
  canvas = new Canvas();
  
  frm.setSize(400, 400);
  frm.add(canvas);
  frm.setVisible(true);
  
  SimpleThread test1 = new SimpleThread(30,"1번 말");
  SimpleThread test2 = new SimpleThread(70,"2번 말");
  SimpleThread test3 = new SimpleThread(110,"3번 말");
  SimpleThread test4 = new SimpleThread(150,"4번 말");
  SimpleThread test5 = new SimpleThread(190,"5번 말");
  SimpleThread test6 = new SimpleThread(230,"6번 말");
  SimpleThread test7 = new SimpleThread(270,"7번 말");
  test1.start();
  test2.start();
  test3.start();
  test4.start();
  test5.start();
  test6.start();
  test7.start();
  
  frm.addWindowListener(new WindowAdapter(){
   public void windowClosing(WindowEvent e){
    System.exit(0);
   }
  }); 
 }
}
%{
unsigned long charCount=0, wordCount=0, lineCount=0;
%}
word [^ \t\n]+
eol \n
%%
{word}    { wordCount++; charCount+=yyleng; }
{eol}    {charCount++; lineCount++; }
.    {charCount++;}
%%
int main(void) 
{
    FILE *file;
    char fn[20];
    printf("Type a ipnut file Name:");
    scanf("%s",fn);
    file=fopen(fn, "r");
    if (!file) {
        fprintf(stderr,"file '%s' could not be opened. \n",fn);
        exit(1);
        }

    yyin=file;
    yylex();
    printf("%d %d %d %s \n", lineCount, wordCount, charCount,fn);

    return 0;
}
yywrap() { return 1; }

+ Recent posts