수다닷컴

질문 제목 :
수업중에 군집화 알고리즘 몇개를 설명듣고 구현하는 것인데 막혔습니다.

threshold 알고리즘

질문 내용 :
표본 패턴 집합 :{x1, x2, ..., xn}
i번째 군집 중심 : zi
t : 임계값

1) z1 -x1
2) if d21 t, z2 - x2, else z1 - x2 d21 = 2와 1 사이의 거리
3) 2)에서 d21 t, 이었다고 가정,
if d31 t & d32 t, z3 - x3,
else if d31 d32, z1 - x3,
else z2 - x3
4) xn 까지 반복

이러한 조건에 순서를 가지고 알고리즘을 구현하는 건데,

먼저 데이터를 입력 받고 (점 x, y 값)
모든 d의 거리를 배열에 넣었습니다.
그러고 배열안에 넣은 데이터중 중복 값을 제거하고
남은 것들 데이터들 중에서 d와 t를 비교하여 영역을 생성하고
다시 기준이 된 점을 제외한 나머지 데이터들의 거리를 비교해서 결과값 배열에 넣어주고 어느 군집에 포함되는지
출력해주는 순서로 생각하고 코딩을 하는데

중복값을 잡아주면서 영역을 나누는 부분에서 막혔습니다.
간단한건데 못하는거 같아서 답답합니다...

struct point
{
int x; // x좌표
int y; // y 좌표
int cluster; // 소속 영역
};
struct cluster
{
int x;
int y;
int inputnum;
};
struct distance
{
int h_input; // 첫번째 점 입력순서
int t_input; // 두번째 점 입력순서
double ht_distance; // 두점 사이의 거리
};

point data[100]; // 점 데이터
distance d_data[200]; // 거리 데이터
distance dc_data[200]; // 중복체크 데이터
cluster c_data[100]; // 클러스터 갯수

void main ()
{
int inputnum = 0;
int distancecounter = 0;
int clustercounter = 1;
input (&inputnum);
data_print (&inputnum);
distance_cal (&inputnum, &distancecounter);
distance_print (&distancecounter);
distance_check (&distancecounter, &clustercounter);
}

메인 함수는 현재 저상태이고

문제가 된 부분은 distance_check () 입니다.

void distance_check (int *dc, int *cc)
{
int counter = 0;
int cc = *cc;
c_data[0].x = data[0].x;
c_data[0].y = data[0].y;
c_data[0].inputnum = 0;
for (int i = 0; i *dc; i++)
{
if (d_data[i].h_input == d_data[i].t_input)
{
}
else
{
dc_data[counter].h_input = d_data[i].h_input;
dc_data[counter].t_input = d_data[i].t_input;
dc_data[counter].ht_distance = d_data[i].ht_distance;
counter++;
}
}
int temp_h;
int temp_t;
printf (\n\n 거리계산 결과\n);
for (int i = 0; i counter; i++)
{
if (dc_data[i].ht_distance t)
{
temp_h = dc_data[i].h_input;
temp_t = dc_data[i].t_input;
for (int j = 0; j counter; j++)
{
if (temp_h = )
{
}
}
if (dc_data[i].ht_distance)
{
}
printf (%f\n, dc_data[i].ht_distance);
c_data[cc].x = data[dc_data[i].t_input].x;
c_data[cc].y = data[dc_data[i].t_input].y;
c_data[cc].inputnum = dc_data[i].t_input;
cc++;
}
}
sp;}
*cc = cc;
}

c_data 배열은 클러스터의 중심으로 결정된 점들의 좌표값과 처음에 입력한 순서가 한묶음으로 들어가고
d_data 배열은 점1, 점2의 입력순서 그리고 그 두점 사이의 거리값이 한묶음으로 들어가있고
dc_data 배열은 중복값을 제거한 내용이 들어간 상태입니다.
위는 자기자신의 좌표값을 서로 비교한 내용(점1과 점1의 거리)를 제거하고 클러스터를 나눠주는 것을 구현하려다 막힌 함수입니다...

코딩쉬다 오랜만에 하니까 머릿속으로는 어떻게할지 생각이 되는데 코드로 표현이 안되네요 도움 부탁합니다.

-----------------------------------------------------------------------------------------------------------------
원 소스입니다. 문제가 되는 부분을 제외하면 단순히 점 입력하고 계산하는 거라 제외했는데 잘못 생각했나봅니다...#include stdio.h
#include conio.h
#include windows.h
#include stdlib.h
#include math.h
void gotoxy (int x, int y)
{
coord cur;
cur.x = x , cur.y = y;
setconsolecursorposition(getstdhandle(std_output_handle), cur);
}
void move_print (int x, int y, char z[])
{
gotoxy (2*x, y);
printf (%s, z);
}
struct point
{
int x; // x좌표
int y; // y 좌표
int cluster; // 소속 영역
};
struct cluster
{
int x;
int y;
int inputnum;
};
struct distance
{
int h_input; // 첫번째 점 입력순서
int t_input; // 두번째 점 입력순서
double ht_distance; // 두점 사이의 거리
};

point data[100]; // 점 데이터
distance d_data[200]; // 거리 데이터
distance dc_data[200]; // 중복체크 데이터
cluster c_data[100]; // 클러스터 갯수
double t; // 임계 값

void input (int *in)
{
int input_x = 0;
int input_y = 0;
int inputcheck_x = 0;
int inputcheck_y = 0;
printf (임계값을 입력하세요 (double형) : );
scanf (%lf, &t);
printf (입력할 수를 입력 하세요 (최대 100) : );
scanf (%d, in);
for (int i = 0; i *in; i++)
{
inputcheck_x = 0;
inputcheck_y = 0;
printf (%d 번째 원소의 x, y값을 차례대로 입력하세요\n, i+1);

while (inputcheck_x == 0)
{
printf (%d 번째 원소의 x값 : , i+1);
scanf(%d, &input_x);
if (input_x 9)
{
printf(x의 범위 초과 다시입력하세요 0 ~ 9\n);
}
else
{
inputcheck_x = 1;
}
}
while (inputcheck_y == 0)
{
printf (%d 번째 원소의 y값 : , i+1);
scanf(%d, &input_y);
if (input_y 9)
{
printf(y의 범위 초과 다시입력하세요 0 ~ 9\n);
}
else
{
inputcheck_y = 1;
}
}
data[i].x = input_x;
data[i].y = input_y;
}
}
void data_print (int *in)
{
printf (\n\n 데이터 입력\n);
printf (입력한 데이터의 갯수 : %d\n입력한 임계값 : %f\n\n, *in, t);
for (int i = 0; i *in; i++)
{
printf (%d번째 원소의 x값 : %d, y값 : %d\n, i+1, data[i].x, data[i].y);
}
}
void distance_cal (int *in, int *dc)
{
int d_x = 0;
int d_y = 0;
int d_xy = 0;
double d = 0;
int counter = *dc;
for (int i = 0; i *in; i++)
{
for (int j = 0; j *in; j++)
{
d_x = abs(data[i].x - data[j].x) * abs(data[i].x - data[j].x);
d_y = abs(data[i].y - data[j].y) * abs(data[i].y - data[j].y);
d_xy = d_x + d_y;
d = sqrt ((double) d_xy);
d_data[counter].h_input = i;
d_data[counter].t_input = j;
d_data[counter].ht_distance = d;
counter++;
}
}
*dc = counter;
}

void distance_print (int *dc)
{
printf (\n\n 거리계산 결과\n);
for (int i = 0; i *dc; i++)
{
printf (%d점과 %d점 사이의 거리 : %f\n, d_data[i].h_input+1, d_data[i].t_input+1, d_data[i].ht_distance);
}
}
void distance_check (int *dc, int *cc)
{
int counter = 0;
int cc = *cc;
c_data[0].x = data[0].x;
c_data[0].y = data[0].y;
c_data[0].inputnum = 0;
for (int i = 0; i *dc; i++)
{
if (d_data[i].h_input == d_data[i].t_input)
{
}
else
{
dc_data[counter].h_input = d_data[i].h_input;
dc_data[counter].t_input = d_data[i].t_input;
dc_data[counter].ht_distance = d_data[i].ht_distance;
counter++;
}
}
int temp_h;
int temp_t;
printf (\n\n 거리계산 결과\n);
for (int i = 0; i counter; i++)
{
if (dc_data[i].ht_distance t)
{
temp_h = dc_data[i].h_input;
temp_t = dc_data[i].t_input;
for (int j = 0; j counter; j++)
{
if (temp_h = )
{
}
}
if (dc_data[i].ht_distance)
{
}
printf (%f\n, dc_data[i].ht_distance);
c_data[cc].x = data[dc_data[i].t_input].x;
c_data[cc].y = data[dc_data[i].t_input].y;
c_data[cc].inputnum = dc_data[i].t_input;
cc++;
}
}
*cc = cc;
for (int i = 0; i cc; i++)
{
printf (입력순서 = %d, x좌표 = %d, y좌표 = %d\n, c_data[i].inputnum, c_data[i].x, c_data[i].y);
}
}
void main ()
{
int inputnum = 0;
int distancecounter = 0;
int clustercounter = 1;
input (&inputnum);
data_print (&inputnum);
distance_cal (&inputnum, &distancecounter);
distance_print (&distancecounter);
distance_check (&distancecounter, &clustercounter);
}

신청하기