changhengliou

func (c *conn) serve(ctx context.Context)

changhengliou

#include <vector>
using namespace std;

class Disjoint_set {
  private:
    // the max depth of the tree depth
    vector<int> _rank;
    // the parent of the each node
    vector<int> _parent;
  public:

changhengliou

#include <vector>
#include <queue>
#include <iostream>
#include <stdexcept>

using namespace std;

// bellman ford's algorithm is an algorithm that finds shortest path
// unlike dijkstra's algorithm, it also works while the cost is negative.
// the time complexity is O(V·E)

changhengliou

#include <vector>
#include <iostream>
using namespace std;

vector<int> dijkstra(vector<vector<pair<int, int>>>& graph) {
  vector<int> record(graph.size(), INT_MAX);
  vector<bool> visited(graph.size(), false);
  int curr = 0;
  record[curr] = 0;
  for (int i = 0; i < graph.size() - 1; i++) {

changhengliou

// ----------- adapter pattern -------------------
public class TargetA
{
    public void Start() { ... }
    public void End() { ... }
}

public class TargetB
{
    public void Begin() { ... }

changhengliou

class BaseController {
  constructor () {
    this.ctx = {
      status: 200,
      body: {}
    };
    const before = this.before || (() => {
      console.log(`Before run`);
      return true;
    });

changhengliou

#include <iostream>

using namespace std;

struct TreeNode {
  int start;
  int end;
  int sum; // or max/min
  TreeNode *left;
  TreeNode *right;

changhengliou

#include <iostream>
#include <queue>

using namespace std;

enum Color { RED, BLACK };

struct Node {
  char val;
  Color color;

changhengliou

#include <algorithm>
#include <iostream>
#include <vector>

using namespace std;

bool default_predicate(int a, int b) { return a > b; }

struct Heap {
private:

changhengliou

#include <cmath>
#include <iostream>
#include <vector>

using namespace std;

class SegmentTree {
private:
  // number of elements
  int _N;