void Particle::printInfo(){ if (ofGetFrameNum() % (int)ofGetFrameRate() == 0){ cout << "Position: " << '(' << getX() << ',' << getY() << ')' << endl; cout << "Speed: " << getSpeed() << "\t" << "Angle:" << getAngle() << endl; cout << "Flow: " << getFlow() << "\t" << "Alpha: " << getAlpha() << endl << endl; } }
void printGraph(GraphFlow *g) { int i = 0; int j = 0; printf("-- graph --\n"); printf("-Edges:\n"); for(i=0; i < getNumNodes(g); i++) { for(j=0; i < getNumNodes(g); i++) { printf("%d ", getEdge(g,i,j)); } printf("\n"); } printf("-Capacity:\n"); for(i=0; i < getNumNodes(g); i++) { for(j=0; i < getNumNodes(g); i++) { printf("%d ", getCapacity(g,i,j)); } printf("\n"); } printf("-Flow:\n"); for(i=0; i < getNumNodes(g); i++) { for(j=0; i < getNumNodes(g); i++) { printf("%d ", getFlow(g,i,j)); } printf("\n"); } }
Flow::~Flow() { // Set a flag to make sure the level computation is triggered again HasLevel::triggerLazyRecomputation(); // Delete existing flowplans if (getOperation() && getBuffer()) { // Loop over operationplans for(OperationPlan::iterator i(getOperation()); i != OperationPlan::end(); ++i) // Loop over flowplans for (auto j = i->beginFlowPlans(); j != i->endFlowPlans(); ) { if (j->getFlow() == this) j.deleteFlowPlan(); else ++j; } } // Delete the flow from the operation and the buffer if (getOperation()) getOperation()->flowdata.erase(this); if (getBuffer()) getBuffer()->flows.erase(this); }
int getResidualCapacity(GraphFlow *g, int node1, int node2) { if(!inRange(g,node1) || !inRange(g,node2)) { printf("Error range in getResidualCapacity of GraphFlow!\n"); exit(-1); } return getCapacity(g,node1,node2) - getFlow(g,node1,node2); }
void KisFlowOpacityOption::apply(KisPainter* painter, const KisPaintInformation& info) { if (m_paintActionType == WASH && m_nodeHasIndirectPaintingSupport) painter->setOpacityUpdateAverage(quint8(getDynamicOpacity(info) * 255.0)); else painter->setOpacityUpdateAverage(quint8(getStaticOpacity() * getDynamicOpacity(info) * 255.0)); painter->setFlow(quint8(getFlow() * 255.0)); }
PyObject* FlowPlan::getattro(const Attribute& attr) { if (attr.isA(Tags::tag_operationplan)) return PythonObject(getOperationPlan()); if (attr.isA(Tags::tag_quantity)) return PythonObject(getQuantity()); if (attr.isA(Tags::tag_flow)) return PythonObject(getFlow()); if (attr.isA(Tags::tag_date)) return PythonObject(getDate()); if (attr.isA(Tags::tag_onhand)) return PythonObject(getOnhand()); if (attr.isA(Tags::tag_buffer)) // Convenient shortcut return PythonObject(getFlow()->getBuffer()); if (attr.isA(Tags::tag_operation)) // Convenient shortcut return PythonObject(getFlow()->getOperation()); return NULL; }
int flow(GraphFlow *g) { int result = 0; int node = 0; for(node = 0; node < getNumNodes(g); node++) { result += getFlow(g,getSource(g),node); } return result; }
int flowConservative2(GraphFlow *g) { int i = 0; int j = 0; int balance = 0; for( i=0; i < getNumNodes(g); i++) { if( i != getSource(g) && i != getSink(g) ) { for(j=0, balance =0; j < getNumNodes(g); j++) { balance += getFlow(g,i,j); } if(balance != 0) return FALSE; } } return TRUE; }
int positiveFlowFromNode(GraphFlow *g, int node) { int i = 0; int result = 0; int flow = 0; if(!inRange(g,node)) { printf("Error range in positiveFlowFromNode!\n"); exit(-1); } for(i=0; i < getNumNodes(g); i++) { flow = getFlow(g,i,node); if(flow < 0) result += -flow; } return result; }
SUMOReal GUIEdge::getScaleValue(size_t activeScheme) const { switch (activeScheme) { case 1: return gSelected.isSelected(getType(), getGlID()); case 2: return getAllowedSpeed(); case 3: return getBruttoOccupancy(); case 4: return getMeanSpeed(); case 5: return getFlow(); case 6: return getRelativeSpeed(); } return 0; }
int main () { FINISH = clock () + (CLOCKS_PER_SEC * 1800) / 1000; freopen ("omax.in", "rt", stdin); freopen ("omax.out", "wt", stdout); #ifdef _DBG_ freopen ("omax.err", "wt", stderr); #endif scanf ("%d", &X); Y = X; n = X + Y + 2; for (int i = 0; i < X; i++) add_edge (0, i + 1, 1); for (int i = 0; i < Y; i++) add_edge (i + X + 1, n - 1, 1); for (int i = 0; i < X; i++) { int c; scanf ("%d", &c); for (int j = 0; j < c; j++) { int b; scanf ("%d", &b); add_edge (i + 1, b + X, 1); } } int flow = getFlow (); if (flow < X) noQuit (); #ifdef _DBG_ printf ("%d\n", flow); #endif memset (vis, 0, sizeof vis); for (int i = 0; i < n; i++) { dfs (i); } printFlow (); return 0; }
/* add packet to the relevent flow */ void buffer_write(Packet* p, bool virtual_f) { bool insertP = FALSE; Flow* f = getFlow(p, &insertP, virtual_f); FHeap* heap = virtual_f ? virtual_flows : flows; if (!insertP) //if we didn't insert the packet { if (flow_isEmpty(f)){ // revived flow flow_enqueue(f, p); heapify(heap->data, heap->count); heap->weight += f->weight; } else { flow_enqueue(f, p); } } }
SUMOReal GUIEdge::getScaleValue(int activeScheme) const { switch (activeScheme) { case 1: return gSelected.isSelected(getType(), getGlID()); case 2: return getAllowedSpeed(); case 3: return getBruttoOccupancy(); case 4: return getMeanSpeed(); case 5: return getFlow(); case 6: return getRelativeSpeed(); case 7: return MSNet::getInstance()->getInsertionControl().getPendingEmits(getLanes()[0]); } return 0; }
fxBool ModemConfig::parseItem(const char* tag, const char* value) { int i; for (i = (sizeof ( atcmds ) / sizeof ( atcmds [0])) -1; i >= 0; i--) if ((strcasecmp( tag , atcmds[i].name )==0) ) { (*this).*atcmds[i].p = parseATCmd(value); return (((fxBool)1) ); } for (i = (sizeof ( fillorders ) / sizeof ( fillorders [0])) -1; i >= 0 ; i--) if ((strcasecmp( tag , fillorders[i].name )==0) ) { (*this).*fillorders[i].p = getFill(value); return (((fxBool)1) ); } for (i = (sizeof ( numbers ) / sizeof ( numbers [0])) -1; i >= 0 ; i--) if ((strcasecmp( tag , numbers[i].name )==0) ) { (*this).*numbers[i].p = atoi(value); return (((fxBool)1) ); } fxBool recognized = ((fxBool)1) ; if ((strcasecmp( tag , "ModemType" )==0) ) type = value; else if ((strcasecmp( tag , "ModemSetVolumeCmd" )==0) ) setVolumeCmds(value); else if ((strcasecmp( tag , "ModemFlowControl" )==0) ) flowControl = getFlow(value); else if ((strcasecmp( tag , "ModemMaxRate" )==0) || (strcasecmp( tag , "ModemRate" )==0) ) maxRate = getRate(value); else if ((strcasecmp( tag , "ModemWaitForConnect" )==0) ) waitForConnect = getBoolean(value); else if ((strcasecmp( tag , "Class2RecvDataTrigger" )==0) ) class2RecvDataTrigger = value; else if ((strcasecmp( tag , "Class2XmitWaitForXON" )==0) ) class2XmitWaitForXON = getBoolean(value); else recognized = ((fxBool)0) ; return (recognized); }
void NetworkInterface::flow_processing(ZMQ_Flow *zflow) { bool src2dst_direction; Flow *flow; if((time_t)zflow->last_switched > (time_t)last_pkt_rcvd) last_pkt_rcvd = zflow->last_switched; /* Updating Flow */ flow = getFlow(zflow->src_mac, zflow->dst_mac, zflow->vlan_id, &zflow->src_ip, &zflow->dst_ip, zflow->src_port, zflow->dst_port, zflow->l4_proto, &src2dst_direction, zflow->first_switched, zflow->last_switched); if(flow == NULL) return; if(zflow->l4_proto == IPPROTO_TCP) flow->updateTcpFlags(zflow->tcp_flags); flow->addFlowStats(src2dst_direction, zflow->pkt_sampling_rate*zflow->in_pkts, zflow->pkt_sampling_rate*zflow->in_bytes, zflow->pkt_sampling_rate*zflow->out_pkts, zflow->pkt_sampling_rate*zflow->out_bytes, zflow->last_switched); flow->setDetectedProtocol(zflow->l7_proto); flow->setJSONInfo(json_object_to_json_string(zflow->additional_fields)); flow->updateActivities(); incStats(zflow->src_ip.isIPv4() ? ETHERTYPE_IP : ETHERTYPE_IPV6, flow->get_detected_protocol(), zflow->pkt_sampling_rate*(zflow->in_bytes + zflow->out_bytes), zflow->pkt_sampling_rate*(zflow->in_pkts + zflow->out_pkts), 24 /* 8 Preamble + 4 CRC + 12 IFG */ + 14 /* Ethernet header */); purgeIdle(zflow->last_switched); }
void elFlowPort::updateValues() { // checkInTimeCount(); if( _emitFlow ) { getFlow(); } if( _emitPressure ) { getPressure(); } if( _emitTemperature ) { getTemperature(); } // updateNumInTimeValues(); if( _setValueType != setValueType::setTypeNone && _autoAdjust ) { // adjustValues(); } }
// Other methods void Particle::update(){ // main method that controls all necessary movement // attraction and repulsion float dy = (ofGetWindowHeight() - ofGetMouseY()) - getY(); float dx = ofGetMouseX() - getX(); if (getAttract() && !getRepel()){ float desired = atan2(dy,dx); float angdiff = desired-getAngle(); if ((angdiff > 0 && abs(angdiff) <= PI) || (angdiff < 0 && abs(angdiff) > PI)){ setAngle(getAngle() + getAlpha()); } else if ((angdiff > 0 && abs(angdiff)>PI) || (angdiff < 0 && abs(angdiff) <= PI)){ setAngle(getAngle() - getAlpha()); } // if (desired+getAlpha()>getAngle() && desired-getAlpha()<getAngle()){ // setSpeed(getSpeed()+getFlow()); // } // else { // if (getSpeed()>ORBITAL_FACTOR*getFlow()){ // setSpeed(getSpeed()-getFlow()); // } // } } else if (getRepel() && !getAttract() && sqrt(pow(dy,2) + pow(dx,2)) <= BARRIER){ float desired = atan2(dy,dx) > 0 ? atan2(dy,dx) - PI : atan2(dy,dx) + PI; float angdiff = desired - getAngle(); if ((angdiff > 0 && abs(angdiff) <= PI) || (angdiff < 0 && abs(angdiff) > PI)){ setAngle(getAngle() + getAlpha()); } else if ((angdiff > 0 && abs(angdiff) > PI) || (angdiff < 0 && abs(angdiff) <= PI)){ setAngle(getAngle() - getAlpha()); } // if (desired+getAlpha()>getAngle() && desired-getAlpha()<getAngle()){ // setSpeed(getSpeed()+getFlow()); // } // else { // if (getSpeed()>ORBITAL_FACTOR*getFlow()){ // setSpeed(getSpeed()-getFlow()); // } // } } else if (getAttract() && getRepel()){ if (getSpeed() > 0){ setSpeed(getSpeed() - getFlow()); } } // life if (getAlive()){ setAngle(getAngle() + ofRandomf() * getAlpha()); setSpeed(getSpeed() + ofRandomf() * getFlow()); setRadius(getRadius() + ofRandomf() * RADIUS_NOISE); } // bounds if (getX() > ofGetWindowWidth() - getRadius() || getX() < getRadius()){ setAngle(-getAngle() + PI); } if (getY() > ofGetWindowHeight() - getRadius() || getY() < getRadius()){ setAngle(-getAngle()); } // position + motion position += velocity; // color float r = getAttract() && getRepel() ? getColor().r + 1 : (getSpeed()/MAX_SPEED) * 255; float g = getAttract() ? getColor().g + 1 : (getY()/ofGetWindowHeight()) * 255; float b = getRepel() ? getColor().b + 1 : (1-getY()/ofGetWindowHeight()) * 255; setColor(r,g,b); }
void NetworkInterface::packet_processing(const u_int32_t when, const u_int64_t time, struct ndpi_ethhdr *eth, u_int16_t vlan_id, struct ndpi_iphdr *iph, struct ndpi_ip6_hdr *ip6, u_int16_t ipsize, u_int16_t rawsize) { bool src2dst_direction; u_int8_t l4_proto; Flow *flow; u_int8_t *eth_src = eth->h_source, *eth_dst = eth->h_dest; IpAddress src_ip, dst_ip; u_int16_t src_port, dst_port; struct ndpi_tcphdr *tcph = NULL; struct ndpi_udphdr *udph = NULL; u_int16_t l4_packet_len; u_int8_t *l4, tcp_flags = 0; u_int8_t *ip; bool is_fragment = false; if(iph != NULL) { /* IPv4 */ if(ipsize < 20) { incStats(ETHERTYPE_IP, NDPI_PROTOCOL_UNKNOWN, rawsize, 1, 24 /* 8 Preamble + 4 CRC + 12 IFG */); return; } if((iph->ihl * 4) > ipsize || ipsize < ntohs(iph->tot_len) || (iph->frag_off & htons(0x1FFF /* IP_OFFSET */)) != 0) { is_fragment = true; } l4_packet_len = ntohs(iph->tot_len) - (iph->ihl * 4); l4_proto = iph->protocol; l4 = ((u_int8_t *) iph + iph->ihl * 4); ip = (u_int8_t*)iph; } else { /* IPv6 */ if(ipsize < sizeof(const struct ndpi_ip6_hdr)) { incStats(ETHERTYPE_IPV6, NDPI_PROTOCOL_UNKNOWN, rawsize, 1, 24 /* 8 Preamble + 4 CRC + 12 IFG */); return; } l4_packet_len = ntohs(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen)-sizeof(const struct ndpi_ip6_hdr); l4_proto = ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt; l4 = (u_int8_t*)ip6 + sizeof(const struct ndpi_ip6_hdr); ip = (u_int8_t*)ip6; } if((l4_proto == IPPROTO_TCP) && (l4_packet_len >= 20)) { /* tcp */ tcph = (struct ndpi_tcphdr *)l4; src_port = tcph->source, dst_port = tcph->dest; tcp_flags = l4[13]; } else if((l4_proto == IPPROTO_UDP) && (l4_packet_len >= 8)) { /* udp */ udph = (struct ndpi_udphdr *)l4; src_port = udph->source, dst_port = udph->dest; } else { /* non tcp/udp protocols */ src_port = dst_port = 0; } if(iph != NULL) { src_ip.set_ipv4(iph->saddr); dst_ip.set_ipv4(iph->daddr); } else { src_ip.set_ipv6(&ip6->ip6_src); dst_ip.set_ipv6(&ip6->ip6_dst); } #if defined(WIN32) && defined(DEMO_WIN32) if(this->ethStats.getNumPackets() > MAX_NUM_PACKETS) { static bool showMsg = false; if(!showMsg) { ntop->getTrace()->traceEvent(TRACE_NORMAL, "-----------------------------------------------------------"); ntop->getTrace()->traceEvent(TRACE_NORMAL, "WARNING: this demo application is a limited ntopng version able to"); ntop->getTrace()->traceEvent(TRACE_NORMAL, "capture up to %d packets. If you are interested", MAX_NUM_PACKETS); ntop->getTrace()->traceEvent(TRACE_NORMAL, "in the full version please have a look at the ntop"); ntop->getTrace()->traceEvent(TRACE_NORMAL, "home page http://www.ntop.org/."); ntop->getTrace()->traceEvent(TRACE_NORMAL, "-----------------------------------------------------------"); ntop->getTrace()->traceEvent(TRACE_NORMAL, ""); showMsg = true; } return; } #endif /* Updating Flow */ flow = getFlow(eth_src, eth_dst, vlan_id, &src_ip, &dst_ip, src_port, dst_port, l4_proto, &src2dst_direction, last_pkt_rcvd, last_pkt_rcvd); if(flow == NULL) { incStats(iph ? ETHERTYPE_IP : ETHERTYPE_IPV6, NDPI_PROTOCOL_UNKNOWN, rawsize, 1, 24 /* 8 Preamble + 4 CRC + 12 IFG */); return; } else { flow->incStats(src2dst_direction, rawsize); if(l4_proto == IPPROTO_TCP) flow->updateTcpFlags(tcp_flags); } /* Protocol Detection */ flow->updateActivities(); if(flow->isDetectionCompleted()) { /* Handle aggregations here */ switch(flow->get_detected_protocol()) { case NDPI_PROTOCOL_DNS: struct ndpi_flow_struct *ndpi_flow = flow->get_ndpi_flow(); struct ndpi_id_struct *cli = (struct ndpi_id_struct*)flow->get_cli_id(); struct ndpi_id_struct *srv = (struct ndpi_id_struct*)flow->get_srv_id(); if(ndpi_flow) { memset(&ndpi_flow->detected_protocol_stack, 0, sizeof(ndpi_flow->detected_protocol_stack)); ndpi_detection_process_packet(ndpi_struct, ndpi_flow, ip, ipsize, (u_int32_t)time, cli, srv); if(ndpi_flow->protos.dns.ret_code != 0) { /* This is a negative reply thus we notify the system that this aggregation must not be tracked */ flow->aggregateInfo((char*)ndpi_flow->host_server_name, l4_proto, NDPI_PROTOCOL_DNS, false); } } break; } flow->processDetectedProtocol(); flow->deleteFlowMemory(); incStats(iph ? ETHERTYPE_IP : ETHERTYPE_IPV6, flow->get_detected_protocol(), rawsize, 1, 24 /* 8 Preamble + 4 CRC + 12 IFG */); return; } else incStats(iph ? ETHERTYPE_IP : ETHERTYPE_IPV6, flow->get_detected_protocol(), rawsize, 1, 24 /* 8 Preamble + 4 CRC + 12 IFG */); if(!is_fragment) { struct ndpi_flow_struct *ndpi_flow = flow->get_ndpi_flow(); struct ndpi_id_struct *cli = (struct ndpi_id_struct*)flow->get_cli_id(); struct ndpi_id_struct *srv = (struct ndpi_id_struct*)flow->get_srv_id(); flow->setDetectedProtocol(ndpi_detection_process_packet(ndpi_struct, ndpi_flow, ip, ipsize, (u_int32_t)time, cli, srv)); } else { // FIX - only handle unfragmented packets // ntop->getTrace()->traceEvent(TRACE_WARNING, "IP fragments are not handled yet!"); } }
void getGeometry(int i, int j, double y) // // Input: i = index of current entry in geometry tables // j = transect index // y = depth of current entry in geometry tables // Output: none // Purpose: computes entries in a transect's geometry tables at a given depth. // { int k; // station index double ylo, // lower elev. of transect slice yhi, // higher elev. of transect slice w, // top width of transect slice wp, // wetted perimeter of transect slice wpSum, // total wetted perimeter across transect a, // area of transect slice aSum, // total area across transect q, // flow across transect slices with same roughness qSum; // total flow across transect int findFlow; // true if flow thru area slice needs updating // --- initialize wpSum = 0.0; aSum = 0.0; qSum = 0.0; // --- examine each horizontal station from left to right for (k = 1; k <= Nstations; k++) { // --- determine low & high elevations for transect sub-section if ( Elev[k-1] >= Elev[k] ) { yhi = Elev[k-1]; ylo = Elev[k]; } else { yhi = Elev[k]; ylo = Elev[k-1]; } // --- skip station if its totally dry if ( ylo >= y ) continue; // --- get top width, area & wetted perimeter values for transect // slice between station k and k-1 getSliceGeom(k, y, ylo, yhi, &w, &a, &wp); // --- update total transect values wpSum += wp; aSum += a; Transect[j].areaTbl[i] += a; Transect[j].widthTbl[i] += w; // --- must update flow if station elevation is above water level if ( Elev[k] >= y ) findFlow = TRUE; else findFlow = FALSE; // --- update flow across transect if called for q = getFlow(k, aSum, wpSum, findFlow); if ( q > 0.0 ) { qSum += q; aSum = 0.0; wpSum = 0.0; } } // next station k // --- find hyd. radius table entry solving Manning eq. with // total flow, total area, and main channel n aSum = Transect[j].areaTbl[i]; if ( aSum == 0.0 ) Transect[j].hradTbl[i] = Transect[j].hradTbl[i-1]; else Transect[j].hradTbl[i] = pow(qSum * Nchannel / 1.49 / aSum, 1.5); }
bool OperationPlan::updateFeasible() { if (!getOperation()->getDetectProblems()) { // No problems to be flagged on this operation setFeasible(true); return true; } // The implementation of this method isn't really cleanly object oriented. It uses // logic which only the different resource and buffer implementation classes should be // aware. if (firstsubopplan) { // Check feasibility of child operationplans for (OperationPlan *i = firstsubopplan; i; i = i->nextsubopplan) { if (!i->updateFeasible()) { setFeasible(false); return false; } } } else { // Before current and before fence problems are only detected on child operationplans if (getConfirmed()) { if (dates.getEnd() < Plan::instance().getCurrent()) { // Before current violation setFeasible(false); return false; } } else { if (dates.getStart() < Plan::instance().getCurrent()) { // Before current violation setFeasible(false); return false; } else if (dates.getStart() < Plan::instance().getCurrent() + oper->getFence() && getProposed()) { // Before fence violation setFeasible(false); return false; } } } if (nextsubopplan && getEnd() > nextsubopplan->getStart() + Duration(1L) && !nextsubopplan->getConfirmed() && owner && !owner->getOperation()->hasType<OperationSplit>() ) { // Precedence violation // Note: 1 second grace period for precedence problems to avoid rounding issues setFeasible(false); return false; } // Verify the capacity constraints for (auto ldplan = getLoadPlans(); ldplan != endLoadPlans(); ++ldplan) { if (ldplan->getResource()->hasType<ResourceDefault>() && ldplan->getQuantity() > 0) { auto curMax = ldplan->getMax(); for ( auto cur = ldplan->getResource()->getLoadPlans().begin(&*ldplan); cur != ldplan->getResource()->getLoadPlans().end(); ++cur ) { if (cur->getOperationPlan() == this && cur->getQuantity() < 0) break; if (cur->getEventType() == 4) curMax = cur->getMax(false); if ( cur->getEventType() != 5 && cur->isLastOnDate() && cur->getOnhand() > curMax + ROUNDING_ERROR ) { // Overload on default resource setFeasible(false); return false; } } } else if (ldplan->getResource()->hasType<ResourceBuckets>()) { for ( auto cur = ldplan->getResource()->getLoadPlans().begin(&*ldplan); cur != ldplan->getResource()->getLoadPlans().end() && cur->getEventType() != 2; ++cur ) { if (cur->getOnhand() < -ROUNDING_ERROR) { // Overloaded capacity on bucketized resource setFeasible(false); return false; } } } } // Verify the material constraints for (auto flplan = beginFlowPlans(); flplan != endFlowPlans(); ++flplan) { if ( !flplan->getFlow()->isConsumer() || flplan->getBuffer()->hasType<BufferInfinite>() ) continue; auto flplaniter = flplan->getBuffer()->getFlowPlans(); for (auto cur = flplaniter.begin(&*flplan); cur != flplaniter.end(); ++cur) { if (cur->getOnhand() < -ROUNDING_ERROR && cur->isLastOnDate()) { // Material shortage setFeasible(false); return false; } } } // After all checks, it turns out to be feasible setFeasible(true); return true; }
int main(void) { int t; scanf("%d", &t); for(int c=1; c<=t; c++) { scanf("%d %d", &h, &w); for(int i=0; i<h; i++) for(int j=0; j<w; j++) { scanf("%d", &map[i][j]); basin[i][j] = 0; } char currentBasin = 'a'; while (1) { int queueStart = 0; int queueEnd = 0; for(int i=0; i<h; i++) for(int j=0; j<w; j++) if (!basin[i][j]) { queue[0].h = i; queue[0].w = j; queueEnd++; basin[i][j] = currentBasin; goto found; } // nothing found break; found: while (queueStart != queueEnd) { int h2, w2; getFlow(queue[queueStart].h, queue[queueStart].w, &h2, &w2); if (h2 >= 0 && !basin[h2][w2]) { queue[queueEnd].h = h2; queue[queueEnd++].w = w2; basin[h2][w2] = currentBasin; } for(int i=0; i<4; i++) { int h3 = queue[queueStart].h + dirs[i][0]; int w3 = queue[queueStart].w + dirs[i][1]; getFlow(h3, w3, &h2, &w2); if (h2 == queue[queueStart].h && w2 == queue[queueStart].w && !basin[h3][w3]) { queue[queueEnd].h = h3; queue[queueEnd++].w = w3; basin[h3][w3] = currentBasin; } } queueStart++; } currentBasin++; } printf("Case #%d:\n", c); for(int i=0; i<h; i++) { for(int j=0; j<w; j++) printf("%c ", basin[i][j]); printf("\n"); } } }