Dynamic Programming Solution to Activity Selection Problem

#include <stdio.h>

#define MAX_ACTIVITY_NUM 100

struct activity
{
int start_time;
int end_time;
};

static struct activity g_activities[MAX_ACTIVITY_NUM];
static int g_solution[MAX_ACTIVITY_NUM][MAX_ACTIVITY_NUM];
static int g_count;

static int g_temp[MAX_ACTIVITY_NUM][MAX_ACTIVITY_NUM];

int find_partition(struct activity *pActivities, int p, int q)
{
int data = pActivities[q].end_time;
int i = p-1, j;

for(j = p; j < q; j++)
{
if(pActivities[j].end_time < data)
{
i++;
struct activity tmp = pActivities[j];
pActivities[j] = pActivities[i];
pActivities[i] = tmp;
}
}

i++;
struct activity tmp = pActivities[q];
pActivities[q] = pActivities[i];
pActivities[i] = tmp;

return i;
}

void quick_sort(struct activity *pActivities, int i, int j)
{
if(i < j)
{
int p = find_partition(pActivities, i, j);
quick_sort(pActivities, i, p -1);
quick_sort(pActivities, p+1, j);
}
}

void find_optimal_activities(struct activity *pActivities, int start, int end)
{
int step, i, j, k;
for(step = 2; step < end -start + 1; step++)
{
for(i = start; i < end - step + 1; i++)
{
j = i + step;
if(pActivities[i].end_time > pActivities[j].start_time)
{
continue;
}
int temp = 0;
int k_max;
for(k = i + 1; k < j; k++)
{
if( pActivities[k].start_time >= pActivities[i].end_time &&
pActivities[k].end_time <= pActivities[j].start_time)
{
if( temp < g_temp[i][k] + g_temp[k][j] + 1)
{
temp = g_temp[i][k] + g_temp[k][j] + 1;
k_max = k;
}
}
}
if(temp > g_temp[i][j] )
{
g_temp[i][j] = temp;
g_solution[i][j] = k_max;
}
}
}
}

void print_solution(int i, int j)
{
if( g_solution[i][j] != 0)
{
print_solution(i, g_solution[i][j]);
printf("[%d, %d]: %d\n", i, j, g_solution[i][j]);
print_solution(g_solution[i][j], j);
}

}

int main(void)
{
freopen("data.txt", "r", stdin);

int count;
scanf("%d", &count);
int p;
for(p = 0; p < count; p++)
{
g_activities[0].start_time = g_activities[0].end_time = -1 << 31;
scanf("%d", &g_count);
int i;
for(i = 1; i <= g_count; i++)
{
scanf("%d %d", &g_activities[i].start_time, &g_activities[i].end_time);
}

g_activities[g_count].start_time = g_activities[g_count].end_time = (1 << 31) -1 ;
quick_sort(g_activities, 0, g_count + 1);

int j;
for( i = 0; i < MAX_ACTIVITY_NUM; i++)
{
for(j = 0; j < MAX_ACTIVITY_NUM; j++)
{
g_temp[i][j] = 0;
g_solution[i][j] = 0;
}
}

find_optimal_activities(g_activities, 0, g_count + 1);
printf("max count of compatible activities: %d\n", g_temp[0][g_count + 1]);
print_solution(0, g_count + 1);
}
return 0;

}

参考：
http://blog.csdn.net/cyp331203/article/details/43242209