void Minkowski_polytope::push_back( Minkowski_vector&& v )
{
m_edges.clear();
for (auto iter=m_triangles.cbegin(), end=m_triangles.cend(); iter!=end; ) {
// I've seen cases of touching objects where this dot product comes out
// to something times 10 to -7. So we can't compare against 0
if (Math::dot_product( Math::Vector(iter->normal), v.v()-iter->a.v() ) > 0.00001) {
// This triangle can be "seen" from the new point, it needs to
// be removed.
push_edge( Edge( iter->a, iter->b ) );
push_edge( Edge( iter->b, iter->c ) );
push_edge( Edge( iter->c, iter->a ) );
iter = m_triangles.erase( iter );
}
else {
++iter;
}
}
for (const auto& e : m_edges) {
m_triangles.push_back( Triangle( v, e.a, e.b ) );
}
}
int getFlow ()
{
S = 0;
T = n - 1;
while (true)
{
#ifdef _DBG_
fprintf (stderr, "!\n");
for (int i = 0; i < n; i++)
for (edge* e = ve[i]; e; e = e->next)
fprintf (stderr, "%d-%d %d/%d\n", i, e->b, e->f, e->p);
#endif
if (clock () > FINISH)
noQuit (1);
push_edge ();
if (!buildMPGraph ())
break;
blockDfs (S);
pop_edge ();
/* tail = 0;
head = 1;
q[0] = 0;
memset (mn, 0, sizeof (int) * n);
mn[0] = 1000000000;
by[0] = NULL;
while (tail < head)
{
int cur = q[tail++];
vis[cur] = vs;
for (edge* e = ve[cur]; e; e = e->next)
if (vis[e->b] != vs && e->f < e->p)
q[head++] = e->b, vis[e->b] = vs, mn[e->b] = min (mn[cur], e->p - e->f), by[e->b] = e->back;
}
vs++;
if (mn[n - 1] <= 0)
break;
flow += mn[n - 1];
edge* cur = by[n - 1];
while (cur)
{
cur->f -= mn[n - 1], cur->back->f += mn[n - 1];
cur = by[cur->b];
}*/
}
int flow = 0;
for (edge* e = ve[S]; e; e = e->next)
flow += e->f;
return flow;
}
int main()
{
int i, A, B;
while (2 == scanf("%d %d", &n, &k)) {
memset(g, -1, sizeof(g));
memset(bk, 0, sizeof(bk));
memset(go, 0, sizeof(go));
for (i = 0; i < n; i++) {
scanf("%d", a+i);
}
vs = 0;
for (i = 1; i < n; i++) {
scanf("%d %d", &A, &B);
push_edge(A-1, B-1);
}
search(0, 0);
printf("%d\n", go[0][k]);
}
return 0;
}
int main(int argc, char* argv[])
{
size_t step_size = 1;
while (1) {
int opt = getopt(argc, argv, "hs:");
if (opt == -1) break;
switch (opt) {
case 's':
step_size = (size_t) strtoul(optarg, NULL, 10);
break;
case 'h':
print_usage(stdout);
return EXIT_SUCCESS;
case '?':
return EXIT_FAILURE;
default:
abort();
}
}
if (optind >= argc) {
print_usage(stderr);
return EXIT_FAILURE;
}
const char* fn = argv[optind];
FILE* f = fopen(fn, "r");
if (f == NULL) {
fprintf(stderr, "Can't open %s for reading.\n", fn);
return EXIT_FAILURE;
}
fprintf(stderr, "Reading adjacency matrix ... ");
/* some rather brittle parsing of matrix market files */
char buffer[512];
fgets(buffer, sizeof(buffer), f);
if (strcmp(buffer, "%%MatrixMarket matrix coordinate integer general\n") != 0) {
fprintf(stderr, "Error: Incorrectly formatted matrix market file.\n");
return EXIT_FAILURE;
}
unsigned int n, n2, m;
fscanf(f, "%u %u %u\n", &n, &n2, &m);
edge_array_t E;
E.size = m;
E.m = 0;
E.es = malloc_or_die(E.size * sizeof(edge_t));
edge_t e;
while (fgets(buffer, sizeof(buffer), f)) {
sscanf(buffer, "%u %u %u\n", &e.u, &e.v, &e.w);
e.u -= 1; e.v -= 1; /* make 0-based */
push_edge(&E, &e);
}
fclose(f);
rng_t* rng = rng_alloc();
shuffle(rng, E.es, E.m);
rng_free(rng);
qsort(E.es, E.m, sizeof(edge_t), edge_cmp);
fprintf(stderr, "done. (%zu edges)\n", E.m);
unsigned int* ds = malloc_or_die(n * sizeof(unsigned int));
size_t i;
for (i = 0; i < E.m; i += step_size) {
size_t c = count_components(E.es + i, n, E.m - i, ds);
printf("%zu\n", c);
fflush(stdout);
}
free(ds);
free(E.es);
return EXIT_SUCCESS;
}
