float color_similarity(CvScalar center_values[], string comparee) {
const char* path ="/Users/Rango/Documents/coding/XCode/TextureSimilarity_data/";
char buff[512];
sprintf(buff, "%s%s.jpg", path, comparee.c_str());
IplImage* src1 = cvLoadImage(buff, CV_LOAD_IMAGE_COLOR);
int k = 0;
float result = 100;
uchar* data = (uchar*)src1->imageData;
int step = src1->widthStep/sizeof(uchar);
int channels = src1->nChannels;
for (int i = 5; i < src1->height; i+=src1->height/10) {
for (int j = 5; j < src1->width; j+=src1->width/10) {
CvScalar s;
s.val[0] = (double)data[i*step+j*channels+0];
s.val[1] = (double)data[i*step+j*channels+1];
s.val[2] = (double)data[i*step+j*channels+2];
result = (k*result + min_distance(center_values, s))/(1+k);
k++;
}
}
return result;
}
double dist_ps(const struct graph *g, long x, long y)
{
long lca, dax, day, dra;
VEC(long) *lx, *ly;
if (!init_metric)
fatal("Error, uninitialized data for metric calcule");
lx = get_list_ancestors(x);
ly = get_list_ancestors(y);
lca = LCA_CA(lx, ly, depth);
dax = min_distance(g, lca, x);
day = min_distance(g, lca, y);
dra = max_distance(g, ROOT, lca);
return dps(dax, day, dra);
}
Stack * dijkstra(List_adj * la,int source,int target,enum dijkstra_mode mode){
Stack * stack = new_stack();
int i,current;
Cell * tmp_list;
int link_value[3][3]= {{1,1},{1,100},{1,3}};
int tmp;
dijkstra_t * dij = new_dijkstra_s(la->size);
if(mode>3 || mode<0)mode=0;
if(source>la->size || source<0)return NULL;
if(target>la->size || target<0)return NULL;
if(la==NULL)return NULL;
for (i=0;i<dij->size;i++){
dij->visited[i] = white;
dij->parent[i] = -2;
dij->distance[i] = 1000000;
}
dij->distance[source] = 0;
dij->parent[source] = -1;
/*printf("dij->size %d\n",dij->size);*/
current = min_distance(dij);
while(current!=-1) {
dij->visited[current] = black;
tmp_list = la->list[current];
while (tmp_list != NULL){
/*printf("a visiter current=%d,target=%d\n",current,tmp_list->target);*/
if ( dij->visited[tmp_list->target] == white){
if (dij->distance[tmp_list->target] > dij->distance[current] + link_value[mode][tmp_list->linkvalue]){
dij->distance[tmp_list->target] = dij->distance[current] + link_value[mode][tmp_list->linkvalue];
dij->parent[tmp_list->target] = current;
}
}
tmp_list = tmp_list->next;
}
current = min_distance(dij);
}
tmp=target;
while(dij->parent[tmp] != -1){
push(stack,tmp);
tmp=dij->parent[tmp];
}
push(stack,source);
return stack;
}
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
int dist[n];
dist[0] = 0;
for (int i = 1; i < n; i++) scanf("%d", &dist[i]);
printf("%d\n", min_distance(n, k, dist));
}
}
double dist_tax_lca(const struct graph *g, long x, long y, long *lcap)
{
long lca, dax, day, drx, dry;
VEC(long) *lx, *ly;
if (!init_metric)
fatal("Error, uninitialized data for metric calcule");
lx = get_list_ancestors(x);
ly = get_list_ancestors(y);
lca = LCA_CA(lx, ly, depth);
*lcap = lca;
dax = min_distance(g, lca, x);
day = min_distance(g, lca, y);
drx = min_distance(g, ROOT, x);
dry = min_distance(g, ROOT, y);
return dtax(dax, day, drx, dry);
}
//subfunction: mark all neighbors of a particle and their neighbors (recursiv!)
void mark_neighbours(int type,int pa_nr,double dist,int *list){
int k;
for (k=0;k<n_part;k++){
//only unmarked and particles with right distance
if ( (partCfg[k].p.type == type) && (list[k] == 0) && (min_distance(partCfg[pa_nr].r.p,partCfg[k].r.p) < dist) ){
//mark particle with same number as calling particle
list[k]=list[pa_nr];
mark_neighbours(type,k,dist,list);
}
}
}
void calc_rdf(int *p1_types, int n_p1, int *p2_types, int n_p2,
double r_min, double r_max, int r_bins, double *rdf)
{
long int cnt=0;
int i,j,t1,t2,ind;
int mixed_flag=0,start;
double inv_bin_width=0.0,bin_width=0.0, dist;
double volume, bin_volume, r_in, r_out;
if(n_p1 == n_p2) {
for(i=0;i<n_p1;i++)
if( p1_types[i] != p2_types[i] ) mixed_flag=1;
}
else mixed_flag=1;
bin_width = (r_max-r_min) / (double)r_bins;
inv_bin_width = 1.0 / bin_width;
for(i=0;i<r_bins;i++) rdf[i] = 0.0;
/* particle loop: p1_types*/
for(i=0; i<n_part; i++) {
for(t1=0; t1<n_p1; t1++) {
if(partCfg[i].p.type == p1_types[t1]) {
/* distinguish mixed and identical rdf's */
if(mixed_flag == 1) start = 0;
else start = (i+1);
/* particle loop: p2_types*/
for(j=start; j<n_part; j++) {
for(t2=0; t2<n_p2; t2++) {
if(partCfg[j].p.type == p2_types[t2]) {
dist = min_distance(partCfg[i].r.p, partCfg[j].r.p);
if(dist > r_min && dist < r_max) {
ind = (int) ( (dist - r_min)*inv_bin_width );
rdf[ind]++;
}
cnt++;
}
}
}
}
}
}
/* normalization */
volume = box_l[0]*box_l[1]*box_l[2];
for(i=0; i<r_bins; i++) {
r_in = i*bin_width + r_min;
r_out = r_in + bin_width;
bin_volume = (4.0/3.0) * PI * ((r_out*r_out*r_out) - (r_in*r_in*r_in));
rdf[i] *= volume / (bin_volume * cnt);
}
}
void main(void)
{
int x[] = { 1, 3, 7, 11, 18};
int m = sizeof(x)/sizeof(int);
int y[] = { 4, 5, 8, 13, 22};
int n = sizeof(y)/sizeof(int);
int i, min_distance(int [], int [], int, int);
printf("\nCompute Minimum Distance Between Two Sorted Arrays");
printf("\n==================================================");
printf("\n\nGiven Array #1 :");
for (i = 0; i < m; i++)
printf("%5d", x[i]);
printf("\n\nGiven Array #2 :");
for (i = 0; i < n; i++)
printf("%5d", y[i]);
printf("\n\nMinimum Distance = %d", min_distance(x, y, m, n));
}
void calc_rdf_intermol_av(int *p1_types, int n_p1, int *p2_types, int n_p2,
double r_min, double r_max, int r_bins, double *rdf, int n_conf)
{
int i,j,k,l,t1,t2,ind,cnt=0,cnt_conf=1;
int mixed_flag=0,start;
double inv_bin_width=0.0,bin_width=0.0, dist;
double volume, bin_volume, r_in, r_out;
double *rdf_tmp, p1[3],p2[3];
rdf_tmp = (double*)malloc(r_bins*sizeof(double));
if(n_p1 == n_p2) {
for(i=0;i<n_p1;i++)
if( p1_types[i] != p2_types[i] ) mixed_flag=1;
}
else mixed_flag=1;
bin_width = (r_max-r_min) / (double)r_bins;
inv_bin_width = 1.0 / bin_width;
volume = box_l[0]*box_l[1]*box_l[2];
for(l=0;l<r_bins;l++) rdf_tmp[l]=rdf[l] = 0.0;
while(cnt_conf<=n_conf) {
for(l=0;l<r_bins;l++) rdf_tmp[l]=0.0;
cnt=0;
k=n_configs-cnt_conf;
for(i=0; i<n_part; i++) {
for(t1=0; t1<n_p1; t1++) {
if(partCfg[i].p.type == p1_types[t1]) {
// distinguish mixed and identical rdf's
if(mixed_flag == 1) start = 0;
else start = (i+1);
//particle loop: p2_types
for(j=start; j<n_part; j++) {
for(t2=0; t2<n_p2; t2++) {
if(partCfg[j].p.type == p2_types[t2]) {
/*see if particles i and j belong to different molecules*/
if(partCfg[i].p.mol_id!=partCfg[j].p.mol_id) {
p1[0]=configs[k][3*i ];p1[1]=configs[k][3*i+1];p1[2]=configs[k][3*i+2];
p2[0]=configs[k][3*j ];p2[1]=configs[k][3*j+1];p2[2]=configs[k][3*j+2];
dist =min_distance(p1, p2);
if(dist > r_min && dist < r_max) {
ind = (int) ( (dist - r_min)*inv_bin_width );
rdf_tmp[ind]++;
}
cnt++;
}
}
}
}
}
}
}
// normalization
for(i=0; i<r_bins; i++) {
r_in = i*bin_width + r_min;
r_out = r_in + bin_width;
bin_volume = (4.0/3.0) * PI * ((r_out*r_out*r_out) - (r_in*r_in*r_in));
rdf[i] += rdf_tmp[i]*volume / (bin_volume * cnt);
}
cnt_conf++;
} //cnt_conf loop
for(i=0; i<r_bins; i++) {
rdf[i] /= (cnt_conf-1);
}
free(rdf_tmp);
}
void analyze_rdfchain(double r_min, double r_max, int r_bins, double **_f1, double **_f2, double **_f3) {
int i, j, ind, c_i, c_j, mon;
double bin_width, inv_bin_width, factor, r_in, r_out, bin_volume, dist, chain_mass,
*cm=NULL, *min_d=NULL, *f1=NULL, *f2=NULL, *f3=NULL;
*_f1 = f1 = (double*)Utils::realloc(f1,r_bins*sizeof(double));
*_f2 = f2 = (double*)Utils::realloc(f2,r_bins*sizeof(double));
*_f3 = f3 = (double*)Utils::realloc(f3,r_bins*sizeof(double));
cm = (double*)Utils::realloc(cm,(chain_n_chains*3)*sizeof(double));
min_d = (double*)Utils::realloc(min_d,(chain_n_chains*chain_n_chains)*sizeof(double));
for(i=0; i<r_bins; i++) {
f1[i] = f2[i] = f3[i] = 0.0;
}
bin_width = (r_max-r_min) / (double)r_bins;
inv_bin_width = 1.0 / bin_width;
for(c_i=0; c_i<chain_n_chains; c_i++) {
cm[3*c_i] = cm[3*c_i+1] = cm[3*c_i+2] = 0.0;
for(c_j=(c_i+1); c_j<chain_n_chains; c_j++) {
min_d[c_i*chain_n_chains+c_j] = box_l[0] + box_l[1] + box_l[2];
}
}
for(c_i=0; c_i<chain_n_chains; c_i++) {
for(i=0; i<chain_length; i++) {
mon = chain_start + c_i*chain_length + i;
cm[3*c_i]+= partCfg[mon].r.p[0]*PMASS(partCfg[mon]);
cm[3*c_i+1]+= partCfg[mon].r.p[1]*PMASS(partCfg[mon]);
cm[3*c_i+2]+= partCfg[mon].r.p[2]*PMASS(partCfg[mon]);
for(c_j=(c_i+1); c_j<chain_n_chains; c_j++) {
for(j=0; j<chain_length; j++) {
dist = min_distance(partCfg[mon].r.p, partCfg[chain_start + c_j*chain_length+j].r.p);
if ((dist > r_min) && (dist < r_max)) {
ind = (int) ( (dist - r_min)*inv_bin_width );
f1[ind]+= 1.0;
}
if (dist<min_d[c_i*chain_n_chains+c_j]) min_d[c_i*chain_n_chains+c_j] = dist;
}
}
}
}
chain_mass = 0;
for(i=0; i<chain_length; i++) chain_mass+= PMASS(partCfg[i]);
for(c_i=0; c_i<chain_n_chains; c_i++) {
cm[3*c_i]/= chain_mass;
cm[3*c_i+1]/= chain_mass;
cm[3*c_i+2]/= chain_mass;
for(c_j=(c_i+1); c_j<chain_n_chains; c_j++) {
dist = min_d[c_i*chain_n_chains+c_j];
if ((dist > r_min) && (dist < r_max)) {
ind = (int) ( (dist - r_min)*inv_bin_width );
f3[ind]+= 1.0;
}
}
}
for(c_i=0; c_i<chain_n_chains; c_i++) {
for(c_j=(c_i+1); c_j<chain_n_chains; c_j++) {
dist = min_distance(&cm[3*c_i],&cm[3*c_j]);
if ((dist > r_min) && (dist < r_max)) {
ind = (int) ( (dist - r_min)*inv_bin_width );
f2[ind]+= 1.0;
}
}
}
/* normalization */
factor = box_l[0]*box_l[1]*box_l[2] *1.5/PI/(chain_n_chains*(chain_n_chains-1));
for(i=0; i<r_bins; i++) {
r_in = i*bin_width + r_min;
r_out = r_in + bin_width;
bin_volume = r_out*r_out*r_out - r_in*r_in*r_in;
f1[i] *= factor / (bin_volume * chain_length*chain_length);
f2[i] *= factor / bin_volume;
f3[i] *= factor / bin_volume;
}
}
int main()
{
char temp[WORD_SIZE+1];
int T;
char line[WORD_SIZE*2]={0};
int i,j;
int mat[N][N]={0};
int n;
char t;
char start[WORD_SIZE+1]={0};
char end[WORD_SIZE+1]={0};
int start_pos=0,end_pos=0;
t= scanf("%d\n",&T);
while(T--)
{
i=0;
while(1)
{
gets(line);
sscanf(line,"%s",dict[i++].word);
if(dict[i-1].word[0]=='*')
{
i--;
break;
}
}
n = i;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
mat[i][j]=0;
for(i=0;i<n;i++)
for(j=0;j<n;j++)
if((strlen(dict[i].word) == strlen(dict[j].word)))
if(diff_word(dict[i].word,dict[j].word)==1)
{
mat[i][j] = 1;
mat[j][i] = 1;
}
t = min_distance(start_pos,end_pos,mat,n);
while(1)
{
if((gets(line))==NULL)
break;;
if(line[0] == '\0')
break;
sscanf(line,"%s %s",start,end);
for(i=0;i<n;i++)
if(strcmp(dict[i].word,start)==0)
{
start_pos = i;
break;
}
for(i=0;i<n;i++)
if(strcmp(dict[i].word,end)==0)
{
end_pos = i;
break;
}
if(strcmp(start,end)==0)
printf("%s %s 0\n",start,end);
else
if(strlen(start) != strlen(end))
printf("%s %s -1\n",start,end);
else
printf("%s %s %d\n",start,end,distance[start_pos][end_pos]);
end[0] = '\0';
}
if(T!=0)
printf("\n");
}
return(0);
}
