#include <iostream>

 #include <vector>

 #include <unordered_map>

 using namespace std;

 class Solution {

 public:

     vector<vector<int>> ruler(int n, vector<int> &minPath) {

         dfs(, n, minPath);

         return result;

     }

     vector<vector<int>> result;

     vector<int> path;

     void dfs(int start, int n, vector<int> &minPath) {

         if (start == n + ) {

             if (fullScale(path)) {

                 result.push_back(path);

                 if (path.size() < minLen) {

                     minLen = path.size();

                     minPath = path;

                 }

             }

             return;

         }

         for (int i = start; i <= n; i++) {

             path.push_back(i);

             dfs(i + , n, minPath);

             path.pop_back();

         }

     }

     bool fullScale(vector<int> path) {

         if (path.size() < ) {

             return false;

         }

         unordered_map<int, int> umap;

         umap[]++;

         umap[]++;

         for (int i = ; i < path.size(); i++) {

             for (int j = ; j < i; j++) {

                 if (path[i] - path[j] < ) {

                     umap[path[i] - path[j]]++;

                     umap[path[j]]++;

                     umap[path[i]]++;

                     umap[ - path[i]]++;

                     umap[ - path[j]]++;

                 }

                 if (umap.size() >= ) {

                     return true;

                 }

             }

         }

         return false;

     }

 private:

     int minLen = ;

 };

 int main() {

     int n = ;

     Solution solu;

     vector<int> minPath;

     vector<vector<int>> res = solu.ruler(n, minPath);

     for (auto x : minPath) {

         cout << x << ", ";

     }

 }