void SetNodeReg::operator_ir(const IntervalVector& box,const IntervalVector& nodebox, NodeType valin, NodeType valout, bool op, double eps) {
int r = Interset(box,nodebox);
switch (r) {
case 2:
if(op && valin != IN)
inter(valin);
else if(!op && valin!= OUT)
_union(valin);
break;
case 1:
if(is_leaf()) {
if( box[var].diam()>eps) {
cut(box);
left->operator_ir(left_box(box),nodebox,valin,valout,op,eps);
right->operator_ir(right_box(box),nodebox,valin,valout,op,eps);
}
else
status = inte_in(status,UNK);
}
else {
left->operator_ir(left_box(box),nodebox,valin,valout,op,eps);
right->operator_ir(right_box(box),nodebox,valin,valout,op,eps);
}
break;
case 0:
if(op && valout!= IN)
inter(valout);
else if(!op && valout!= OUT)
_union(valout);
break;
}
}
static void
calc_node_type(cairo_t *cr, designer_node_type_t *nt)
{
node_type_data_t *ntd = node_type_data(nt);
_rect_t br, ir, or, sr;
ntd->is = g_slist_length(nt->input_slot_specs);
ntd->os = g_slist_length(nt->output_slot_specs);
set_slot_font(cr);
sr = text_rect(cr, "Mg");
/* add sep space */
sr.s.h += 3;
ir = _rect(0, 0, 10, 0);
for (int i=0; i<ntd->is; i++) {
designer_slot_spec_t *slot =
g_slist_nth_data(nt->input_slot_specs, i);
slot_spec_data_t *ssd = slot_spec_data(slot);
ssd->offset = _size(3, 5 + sr.s.h * i);
ir = _union(ir, text_rect(cr, slot->name));
}
/* offset left */
ir = _offset(ir, _size(0, 5));
/* add slot and sep space */
ir.s.w += 5+5;
/* height including sep space */
ir.s.h = ntd->is * sr.s.h - 3;
or = _rect(0, 0, 10, 0);
for (int i=0; i<ntd->os; i++) {
designer_slot_spec_t *slot =
g_slist_nth_data(nt->output_slot_specs, i);
slot_spec_data_t *ssd = slot_spec_data(slot);
ssd->offset = _size(3, 5 + sr.s.h * i);
or = _union(or, text_rect(cr, slot->name));
}
/* move right, including sep space */
or = _offset(or, _size(ir.s.w + 5, 5));
/* add slot and sep space */
or.s.w += 5+5;
/* height including sep space */
or.s.h = ntd->os * sr.s.h - 3;
br = _union(ir, or);
/* reserve space around area */
br = _inset(br, _size(-5, -5));
ntd->br = br;
ntd->ir = _splith(&ir, 6);
_splith(&or, or.s.w - 6);
ntd->or = or;
ntd->sr = sr;
}
int main(void) {
int nodes[10];
printf("Node count: %d\n", NODE_COUNT);
initialize_nodes(nodes, NODE_COUNT);
print_nodes(nodes, NODE_COUNT);
_union(3, 4, nodes, NODE_COUNT);
_union(4, 1, nodes, NODE_COUNT);
printf("%d\n", connected(1, 3, nodes));
printf("%d\n", connected(1, 7, nodes));
return 0;
}
static _rect_t
recalc_area(cairo_t *cr, widget_data_t *data)
{
_rect_t area;
int count = 0;
/* no valid data */
if (!data || !data->design || !data->design->nodes)
return _zeror;
/* check the nodes */
for (GSList *list = data->design->nodes;
list != NULL; list = list->next) {
designer_node_t *node = list->data;
if (cr) {
calc_node_type(cr, node->type);
calc_node(cr, node);
}
node_data_t *nd = node_data(node);
_rect_t nr = _offset(nd->nr, _ptos(nd->origin));
area = (count++) ? _union(area, nr) : nr;
}
return _inset(area, _size(-40, -20));
}
int main() {
int parents[101], ranks[101];
WPI edges[10001];
int N, M, s, t, w;
FORCAS {
cin >> N >> M;
FORI(N) {
ranks[i] = 0;
parents[i] = i;
}
FORI(M) {
cin >> s >> t >> w;
edges[i] = WPI(-w, PI(s,t));
}
sort(edges, edges+M);
int min = 1000000;
FORI(M) {
w = edges[i].first;
PI p = edges[i].second;
if(_union(p.P1, p.P2, parents, ranks)) {
min = MIN(min, -w);
}
}
cout << "Case #" << cas+1 << ": " << min << endl;
}
}
void SetNodeReg::cleave(const IntervalVector& box, Ctc& Ctcin, Ctc& Ctcout, const double eps) {
if(is_leaf() && status == OUT)
return;
IntervalVector box1(box);
IntervalVector box2(box);
//try{Ctcin.contract(box1);}
//catch(EmptyBoxException&){inter(OUT);return;}
Ctcin.contract(box1);
if(box1.is_empty()) {
inter(OUT);
return;
}
//try{Ctcout.contract(box2);}
//catch(EmptyBoxException&){_union(IN);return;}
Ctcout.contract(box2);
if(box2.is_empty()) {
_union(IN);return;
}
if(is_leaf()) {
if(box[var].diam()>eps) {
cut(box);
left->cleave(left_box(box),Ctcin,Ctcout,eps);
right->cleave(right_box(box),Ctcin,Ctcout,eps);
}
else
status = inte(status,UNK);
}
else {
left->cleave(left_box(box),Ctcin,Ctcout,eps);
right->cleave(right_box(box),Ctcin,Ctcout,eps);
}
}
void SetNodeReg::cleave(const IntervalVector& box, Sep& sep, const double eps) {
if(is_leaf() && status == OUT)
return;
IntervalVector box1(box);
IntervalVector box2(box);
sep.separate(box1,box2);
if(box1.is_empty()){
inter(OUT);
// cout<<"box: "<<box<<" set to OUT"<<endl;
}
else if(box2.is_empty()){
_union(IN);
cout<<"box: "<<box<<" set to IN"<<endl;
}
else // continu until box1 and box2 are disjoint
{
if(is_leaf()) {
if(box[var].diam()>eps) {
cut(box);
left->cleave(left_box(box),sep,eps);
right->cleave(right_box(box),sep,eps);
}
else
status = inte(status,UNK);
}
else {
left->cleave(left_box(box),sep,eps);
right->cleave(right_box(box),sep,eps);
}
}
}
static void
update_area_conditional(widget_data_t *data, int force)
{
cairo_t *cr = NULL;
if (force)
cr = gdk_cairo_create(
GTK_WIDGET (data->drawing_area)->window);
_rect_t ua = recalc_area(cr, data);
/* nothing relevant changed */
if (!force && _eqr(data->used_area, ua))
return;
/* in drawing coordinates */
data->used_area = ua;
_rect_t va;
va.o = get_scroll_origin(data);
/* FIXME: needs to correct for scrollers */
va.s = get_visible_size(data);
/* in drawing coordinates */
data->visible_area = va;
_rect_t ca = _union(ua, va);
/* nothing changed for the scroll area */
if (!force && _eqr(data->combined_area, ca))
return;
/* in drawing coordinates */
data->combined_area = ca;
// _point_t vo = _stop(_delta(ca.o, va.o));
#ifdef DEBUG_OUTPUT
g_print("origin: [%f,%f,%f,%f], [%f,%f,%f,%f]\n",
va.o.x, va.o.y, va.s.w, va.s.h,
ca.o.x, ca.o.y, ca.s.w, ca.s.h);
#endif
// set_scrollable_size (data, ca.s);
// set_scroll_origin (data, vo);
set_scroll_parameters(data, data->hadjustment,
ca.o.x, ca.o.x + ca.s.w, va.s.w);
set_scroll_parameters(data, data->vadjustment,
ca.o.y, ca.o.y + ca.s.h, va.s.h);
gtk_widget_queue_draw_area(GTK_WIDGET(data->drawing_area),
0, 0, va.s.w, va.s.h);
if (force)
cairo_destroy(cr);
}
void rects<_t, _rt, _it>::update_bounds() {
rects_type::iterator it;
for (it = _rects.begin(); it != _rects.end(); ++it) {
it->adjust_to_concept();
if (it == _rects.begin()) {
_x0 = it->_x0;
_y0 = it->_y0;
_x1 = it->_x1;
_y1 = it->_y1;
} else {
_union(*it);
}
}
}
int main() {
int N, parents[100], ranks[100], sizes[100];
Point2D positions[100];
double radius[100];
while(true) {
cin >> N;
if(N == -1)
return 0;
FORI(N) {
ranks[i] = sizes[i] = 0;
parents[i] = i;
}
// Read input:
FORI(N) {
cin >> positions[i].XX >> positions[i].YY >> radius[i];
double r1 = radius[i];
for(int j = 0; j < i; ++j) {
double d = dist(positions[i], positions[j]);
double r2 = radius[j];
if(d > r1+r2) {
//cerr << "NO TOUCH " << i << " "<< j << endl;
continue; // Not even touching.
}
if(r2 > d+r1 || r1 > d+r2) {
//cerr << "INSIDE " << i << " " << j << ", dist=" << d << ", r0=" << r1 <<", r1=" << r2 << endl;
continue; // Inside, but not touching.
}
//cerr << "Join " << i << " and " << j << endl;
_union(i, j, parents, ranks);
}
}
int max = 0;
FORI(N) {
int k = find(i, parents);
++sizes[k];
if(sizes[k] > max)
max = sizes[k];
}
if(max == 1)
printf("The largest component contains 1 ring.\n");
else
printf("The largest component contains %d rings.\n", max);
}
return 0;
}
static void
calc_node(cairo_t *cr, designer_node_t *n)
{
node_data_t *nd = node_data(n);
node_type_data_t *ntd = node_type_data(n->type);
_rect_t nr, lr, tr, ir, or, br, xr;
set_title_font(cr);
lr = text_rect(cr, n->name);
tr = _inset(lr, _size(-5, -5));
tr.s.w += 20; /* button space */
br = ntd->br;
/* move into place */
br.o.y = tr.o.y + tr.s.h;
nr = _union(tr, br);
/* break down areas once again */
br = nr; tr = _splitv(&br, tr.s.h);
/* split off close button */
xr = tr; _splith(&xr, tr.s.w - 16);
xr = _splitv(&xr, 16);
xr = _inset(xr, _size(4, 4));
ir = ntd->ir;
/* align inputs to the left */
ir.o = _move(br.o, _size(5, 5));
or = ntd->or;
/* align outputs to the right */
or.o = _move(br.o, _size(br.s.w - or.s.w - 5, 5));
nd->nr = nr;
nd->lr = lr;
nd->tr = tr;
nd->br = br;
nd->ir = ir;
nd->or = or;
nd->xr = xr;
}
